sig
  module Plus :
    sig
      module type S =
        sig
          type 'a t
          val zero : unit -> 'Monads.Std.Monad.Plus.S.t
          val plus :
            'Monads.Std.Monad.Plus.S.t ->
            'Monads.Std.Monad.Plus.S.t -> 'Monads.Std.Monad.Plus.S.t
        end
      module type S2 =
        sig
          type ('a, 'e) t
          val zero : unit -> ('a, 'e) Monads.Std.Monad.Plus.S2.t
          val plus :
            ('a, 'e) Monads.Std.Monad.Plus.S2.t ->
            ('a, 'e) Monads.Std.Monad.Plus.S2.t ->
            ('a, 'e) Monads.Std.Monad.Plus.S2.t
        end
    end
  module Fail :
    sig
      module type S =
        sig
          type 'a error
          type 'a t
          val fail :
            'Monads.Std.Monad.Fail.S.error -> 'Monads.Std.Monad.Fail.S.t
          val catch :
            'Monads.Std.Monad.Fail.S.t ->
            ('Monads.Std.Monad.Fail.S.error -> 'Monads.Std.Monad.Fail.S.t) ->
            'Monads.Std.Monad.Fail.S.t
        end
      module type S2 =
        sig
          type 'a error
          type ('a, 'e) t
          val fail :
            'Monads.Std.Monad.Fail.S2.error ->
            ('a, 'e) Monads.Std.Monad.Fail.S2.t
          val catch :
            ('a, 'e) Monads.Std.Monad.Fail.S2.t ->
            ('Monads.Std.Monad.Fail.S2.error ->
             ('a, 'e) Monads.Std.Monad.Fail.S2.t) ->
            ('a, 'e) Monads.Std.Monad.Fail.S2.t
        end
    end
  module Choice :
    sig
      module type Basic =
        sig
          type 'a t
          val pure : '-> 'Monads.Std.Monad.Choice.Basic.t
          val zero : unit -> 'Monads.Std.Monad.Choice.Basic.t
        end
      module type S =
        sig
          type 'a t
          val pure : '-> 'a t
          val zero : unit -> 'a t
          val accept : '-> 'Monads.Std.Monad.Choice.S.t
          val reject : unit -> 'Monads.Std.Monad.Choice.S.t
          val guard : bool -> unit Monads.Std.Monad.Choice.S.t
          val on :
            bool ->
            unit Monads.Std.Monad.Choice.S.t ->
            unit Monads.Std.Monad.Choice.S.t
          val unless :
            bool ->
            unit Monads.Std.Monad.Choice.S.t ->
            unit Monads.Std.Monad.Choice.S.t
        end
      module type Basic2 =
        sig
          type ('a, 'e) t
          val pure : '-> ('a, 'e) Monads.Std.Monad.Choice.Basic2.t
          val zero : unit -> ('a, 'e) Monads.Std.Monad.Choice.Basic2.t
        end
      module type S2 =
        sig
          type ('a, 'e) t
          val pure : '-> ('a, 'e) t
          val zero : unit -> ('a, 'e) t
          val accept : '-> ('a, 'e) Monads.Std.Monad.Choice.S2.t
          val reject : unit -> ('a, 'e) Monads.Std.Monad.Choice.S2.t
          val guard : bool -> (unit, 'e) Monads.Std.Monad.Choice.S2.t
          val on :
            bool ->
            (unit, 'e) Monads.Std.Monad.Choice.S2.t ->
            (unit, 'e) Monads.Std.Monad.Choice.S2.t
          val unless :
            bool ->
            (unit, 'e) Monads.Std.Monad.Choice.S2.t ->
            (unit, 'e) Monads.Std.Monad.Choice.S2.t
        end
      module Make :
        functor (M : Basic->
          sig
            val pure : '-> 'M.t
            val zero : unit -> 'M.t
            val accept : '-> 'M.t
            val reject : unit -> 'M.t
            val guard : bool -> unit M.t
            val on : bool -> unit M.t -> unit M.t
            val unless : bool -> unit M.t -> unit M.t
          end
      module Make2 :
        functor (M : Basic2->
          sig
            val pure : '-> ('a, 'e) M.t
            val zero : unit -> ('a, 'e) M.t
            val accept : '-> ('a, 'e) M.t
            val reject : unit -> ('a, 'e) M.t
            val guard : bool -> (unit, 'e) M.t
            val on : bool -> (unit, 'e) M.t -> (unit, 'e) M.t
            val unless : bool -> (unit, 'e) M.t -> (unit, 'e) M.t
          end
    end
  module Trans :
    sig
      module type S =
        sig
          type 'a t
          type 'a m
          type 'a e
          val lift :
            'Monads.Std.Monad.Trans.S.m -> 'Monads.Std.Monad.Trans.S.t
          val run :
            'Monads.Std.Monad.Trans.S.t -> 'Monads.Std.Monad.Trans.S.e
        end
      module type S1 =
        sig
          type ('a, 'e) t
          type 'a m
          type ('a, 'e) e
          val lift :
            'Monads.Std.Monad.Trans.S1.m ->
            ('a, 'e) Monads.Std.Monad.Trans.S1.t
          val run :
            ('a, 'e) Monads.Std.Monad.Trans.S1.t ->
            ('a, 'e) Monads.Std.Monad.Trans.S1.e
        end
      module type S2 =
        sig
          type ('a, 'e) t
          type ('a, 'e) m
          type ('a, 'e) e
          val lift :
            ('a, 'e) Monads.Std.Monad.Trans.S2.m ->
            ('a, 'e) Monads.Std.Monad.Trans.S2.t
          val run :
            ('a, 'e) Monads.Std.Monad.Trans.S2.t ->
            ('a, 'e) Monads.Std.Monad.Trans.S2.e
        end
    end
  module type Basic =
    sig
      type 'a t
      val bind :
        'Monads.Std.Monad.Basic.t ->
        ('-> 'Monads.Std.Monad.Basic.t) -> 'Monads.Std.Monad.Basic.t
      val return : '-> 'Monads.Std.Monad.Basic.t
      val map :
        [ `Custom of
            'Monads.Std.Monad.Basic.t ->
            f:('-> 'b) -> 'Monads.Std.Monad.Basic.t
        | `Define_using_bind ]
    end
  module type Basic2 =
    sig
      type ('a, 'e) t
      val bind :
        ('a, 'e) Monads.Std.Monad.Basic2.t ->
        ('-> ('b, 'e) Monads.Std.Monad.Basic2.t) ->
        ('b, 'e) Monads.Std.Monad.Basic2.t
      val map :
        [ `Custom of
            ('a, 'e) Monads.Std.Monad.Basic2.t ->
            f:('-> 'b) -> ('b, 'e) Monads.Std.Monad.Basic2.t
        | `Define_using_bind ]
      val return : '-> ('a, 'b) Monads.Std.Monad.Basic2.t
    end
  module Collection :
    sig
      module type Basic =
        sig
          type 'a t
          val return : '-> 'Monads.Std.Monad.Collection.Basic.t
          val zero : unit -> 'a t
          val plus : 'a t -> 'a t -> 'a t
        end
      module type Eager =
        sig
          type 'a t
          val return : '-> 'a t
          val zero : unit -> 'a t
          val plus : 'a t -> 'a t -> 'a t
          val fold : 'a t -> init:'-> f:('-> '-> 's) -> 's
        end
      module type Delay =
        sig
          type 'a t
          val return : '-> 'a t
          val zero : unit -> 'a t
          val plus : 'a t -> 'a t -> 'a t
          val fold :
            'a t ->
            init:'-> f:('-> '-> ('-> 'r) -> 'r) -> ('-> 'r) -> 'r
        end
      module type S2 =
        sig
          type ('a, 'e) m
          type 'a t
          val all :
            ('a, 'e) Monads.Std.Monad.Collection.S2.m
            Monads.Std.Monad.Collection.S2.t ->
            ('Monads.Std.Monad.Collection.S2.t, 'e)
            Monads.Std.Monad.Collection.S2.m
          val all_ignore :
            ('a, 'e) Monads.Std.Monad.Collection.S2.m
            Monads.Std.Monad.Collection.S2.t ->
            (unit, 'e) Monads.Std.Monad.Collection.S2.m
          val sequence :
            (unit, 'e) Monads.Std.Monad.Collection.S2.m
            Monads.Std.Monad.Collection.S2.t ->
            (unit, 'e) Monads.Std.Monad.Collection.S2.m
          val map :
            'Monads.Std.Monad.Collection.S2.t ->
            f:('-> ('b, 'e) Monads.Std.Monad.Collection.S2.m) ->
            ('Monads.Std.Monad.Collection.S2.t, 'e)
            Monads.Std.Monad.Collection.S2.m
          val iter :
            'Monads.Std.Monad.Collection.S2.t ->
            f:('-> (unit, 'e) Monads.Std.Monad.Collection.S2.m) ->
            (unit, 'e) Monads.Std.Monad.Collection.S2.m
          val fold :
            'Monads.Std.Monad.Collection.S2.t ->
            init:'->
            f:('-> '-> ('b, 'e) Monads.Std.Monad.Collection.S2.m) ->
            ('b, 'e) Monads.Std.Monad.Collection.S2.m
          val fold_left :
            'Monads.Std.Monad.Collection.S2.t ->
            init:'->
            f:('-> '-> ('b, 'e) Monads.Std.Monad.Collection.S2.m) ->
            ('b, 'e) Monads.Std.Monad.Collection.S2.m
          val fold_right :
            'Monads.Std.Monad.Collection.S2.t ->
            f:('-> '-> ('b, 'e) Monads.Std.Monad.Collection.S2.m) ->
            init:'-> ('b, 'e) Monads.Std.Monad.Collection.S2.m
          val reduce :
            'Monads.Std.Monad.Collection.S2.t ->
            f:('-> '-> ('a, 'e) Monads.Std.Monad.Collection.S2.m) ->
            ('a option, 'e) Monads.Std.Monad.Collection.S2.m
          val exists :
            'Monads.Std.Monad.Collection.S2.t ->
            f:('-> (bool, 'e) Monads.Std.Monad.Collection.S2.m) ->
            (bool, 'e) Monads.Std.Monad.Collection.S2.m
          val for_all :
            'Monads.Std.Monad.Collection.S2.t ->
            f:('-> (bool, 'e) Monads.Std.Monad.Collection.S2.m) ->
            (bool, 'e) Monads.Std.Monad.Collection.S2.m
          val count :
            'Monads.Std.Monad.Collection.S2.t ->
            f:('-> (bool, 'e) Monads.Std.Monad.Collection.S2.m) ->
            (int, 'e) Monads.Std.Monad.Collection.S2.m
          val map_reduce :
            (module Monads.Std.Monoid.S with type t = 'a) ->
            'Monads.Std.Monad.Collection.S2.t ->
            f:('-> ('a, 'e) Monads.Std.Monad.Collection.S2.m) ->
            ('a, 'e) Monads.Std.Monad.Collection.S2.m
          val find :
            'Monads.Std.Monad.Collection.S2.t ->
            f:('-> (bool, 'e) Monads.Std.Monad.Collection.S2.m) ->
            ('a option, 'e) Monads.Std.Monad.Collection.S2.m
          val find_map :
            'Monads.Std.Monad.Collection.S2.t ->
            f:('-> ('b option, 'e) Monads.Std.Monad.Collection.S2.m) ->
            ('b option, 'e) Monads.Std.Monad.Collection.S2.m
          val filter :
            'Monads.Std.Monad.Collection.S2.t ->
            f:('-> (bool, 'e) Monads.Std.Monad.Collection.S2.m) ->
            ('Monads.Std.Monad.Collection.S2.t, 'e)
            Monads.Std.Monad.Collection.S2.m
          val filter_map :
            'Monads.Std.Monad.Collection.S2.t ->
            f:('-> ('b option, 'e) Monads.Std.Monad.Collection.S2.m) ->
            ('Monads.Std.Monad.Collection.S2.t, 'e)
            Monads.Std.Monad.Collection.S2.m
        end
      module type S =
        sig
          type 'a m
          type 'a t
          val all :
            'Monads.Std.Monad.Collection.S.m
            Monads.Std.Monad.Collection.S.t ->
            'Monads.Std.Monad.Collection.S.t
            Monads.Std.Monad.Collection.S.m
          val all_ignore :
            'Monads.Std.Monad.Collection.S.m
            Monads.Std.Monad.Collection.S.t ->
            unit Monads.Std.Monad.Collection.S.m
          val sequence :
            unit Monads.Std.Monad.Collection.S.m
            Monads.Std.Monad.Collection.S.t ->
            unit Monads.Std.Monad.Collection.S.m
          val map :
            'Monads.Std.Monad.Collection.S.t ->
            f:('-> 'Monads.Std.Monad.Collection.S.m) ->
            'Monads.Std.Monad.Collection.S.t
            Monads.Std.Monad.Collection.S.m
          val iter :
            'Monads.Std.Monad.Collection.S.t ->
            f:('-> unit Monads.Std.Monad.Collection.S.m) ->
            unit Monads.Std.Monad.Collection.S.m
          val fold :
            'Monads.Std.Monad.Collection.S.t ->
            init:'->
            f:('-> '-> 'Monads.Std.Monad.Collection.S.m) ->
            'Monads.Std.Monad.Collection.S.m
          val fold_left :
            'Monads.Std.Monad.Collection.S.t ->
            init:'->
            f:('-> '-> 'Monads.Std.Monad.Collection.S.m) ->
            'Monads.Std.Monad.Collection.S.m
          val fold_right :
            'Monads.Std.Monad.Collection.S.t ->
            f:('-> '-> 'Monads.Std.Monad.Collection.S.m) ->
            init:'-> 'Monads.Std.Monad.Collection.S.m
          val reduce :
            'Monads.Std.Monad.Collection.S.t ->
            f:('-> '-> 'Monads.Std.Monad.Collection.S.m) ->
            'a option Monads.Std.Monad.Collection.S.m
          val exists :
            'Monads.Std.Monad.Collection.S.t ->
            f:('-> bool Monads.Std.Monad.Collection.S.m) ->
            bool Monads.Std.Monad.Collection.S.m
          val for_all :
            'Monads.Std.Monad.Collection.S.t ->
            f:('-> bool Monads.Std.Monad.Collection.S.m) ->
            bool Monads.Std.Monad.Collection.S.m
          val count :
            'Monads.Std.Monad.Collection.S.t ->
            f:('-> bool Monads.Std.Monad.Collection.S.m) ->
            int Monads.Std.Monad.Collection.S.m
          val map_reduce :
            (module Monads.Std.Monoid.S with type t = 'a) ->
            'Monads.Std.Monad.Collection.S.t ->
            f:('-> 'Monads.Std.Monad.Collection.S.m) ->
            'Monads.Std.Monad.Collection.S.m
          val find :
            'Monads.Std.Monad.Collection.S.t ->
            f:('-> bool Monads.Std.Monad.Collection.S.m) ->
            'a option Monads.Std.Monad.Collection.S.m
          val find_map :
            'Monads.Std.Monad.Collection.S.t ->
            f:('-> 'b option Monads.Std.Monad.Collection.S.m) ->
            'b option Monads.Std.Monad.Collection.S.m
          val filter :
            'Monads.Std.Monad.Collection.S.t ->
            f:('-> bool Monads.Std.Monad.Collection.S.m) ->
            'Monads.Std.Monad.Collection.S.t
            Monads.Std.Monad.Collection.S.m
          val filter_map :
            'Monads.Std.Monad.Collection.S.t ->
            f:('-> 'b option Monads.Std.Monad.Collection.S.m) ->
            'Monads.Std.Monad.Collection.S.t
            Monads.Std.Monad.Collection.S.m
        end
    end
  module Syntax :
    sig
      module type S =
        sig
          type 'a t
          val ( >>= ) :
            'Monads.Std.Monad.Syntax.S.t ->
            ('-> 'Monads.Std.Monad.Syntax.S.t) ->
            'Monads.Std.Monad.Syntax.S.t
          val ( >>| ) :
            'Monads.Std.Monad.Syntax.S.t ->
            ('-> 'b) -> 'Monads.Std.Monad.Syntax.S.t
          val ( >=> ) :
            ('-> 'Monads.Std.Monad.Syntax.S.t) ->
            ('-> 'Monads.Std.Monad.Syntax.S.t) ->
            '-> 'Monads.Std.Monad.Syntax.S.t
          val ( !! ) : '-> 'Monads.Std.Monad.Syntax.S.t
          val ( !$ ) :
            ('-> 'b) ->
            'Monads.Std.Monad.Syntax.S.t -> 'Monads.Std.Monad.Syntax.S.t
          val ( !$$ ) :
            ('-> '-> 'c) ->
            'Monads.Std.Monad.Syntax.S.t ->
            'Monads.Std.Monad.Syntax.S.t -> 'Monads.Std.Monad.Syntax.S.t
          val ( !$$$ ) :
            ('-> '-> '-> 'd) ->
            'Monads.Std.Monad.Syntax.S.t ->
            'Monads.Std.Monad.Syntax.S.t ->
            'Monads.Std.Monad.Syntax.S.t -> 'Monads.Std.Monad.Syntax.S.t
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            'Monads.Std.Monad.Syntax.S.t ->
            'Monads.Std.Monad.Syntax.S.t ->
            'Monads.Std.Monad.Syntax.S.t ->
            'Monads.Std.Monad.Syntax.S.t -> 'Monads.Std.Monad.Syntax.S.t
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            'Monads.Std.Monad.Syntax.S.t ->
            'Monads.Std.Monad.Syntax.S.t ->
            'Monads.Std.Monad.Syntax.S.t ->
            'Monads.Std.Monad.Syntax.S.t ->
            'Monads.Std.Monad.Syntax.S.t -> 'Monads.Std.Monad.Syntax.S.t
        end
      module type S2 =
        sig
          type ('a, 'e) t
          val ( >>= ) :
            ('a, 'e) Monads.Std.Monad.Syntax.S2.t ->
            ('-> ('b, 'e) Monads.Std.Monad.Syntax.S2.t) ->
            ('b, 'e) Monads.Std.Monad.Syntax.S2.t
          val ( >>| ) :
            ('a, 'e) Monads.Std.Monad.Syntax.S2.t ->
            ('-> 'b) -> ('b, 'e) Monads.Std.Monad.Syntax.S2.t
          val ( >=> ) :
            ('-> ('b, 'e) Monads.Std.Monad.Syntax.S2.t) ->
            ('-> ('c, 'e) Monads.Std.Monad.Syntax.S2.t) ->
            '-> ('c, 'e) Monads.Std.Monad.Syntax.S2.t
          val ( !! ) : '-> ('a, 'e) Monads.Std.Monad.Syntax.S2.t
          val ( !$ ) :
            ('-> 'b) ->
            ('a, 'e) Monads.Std.Monad.Syntax.S2.t ->
            ('b, 'e) Monads.Std.Monad.Syntax.S2.t
          val ( !$$ ) :
            ('-> '-> 'c) ->
            ('a, 'e) Monads.Std.Monad.Syntax.S2.t ->
            ('b, 'e) Monads.Std.Monad.Syntax.S2.t ->
            ('c, 'e) Monads.Std.Monad.Syntax.S2.t
          val ( !$$$ ) :
            ('-> '-> '-> 'd) ->
            ('a, 'e) Monads.Std.Monad.Syntax.S2.t ->
            ('b, 'e) Monads.Std.Monad.Syntax.S2.t ->
            ('c, 'e) Monads.Std.Monad.Syntax.S2.t ->
            ('d, 'e) Monads.Std.Monad.Syntax.S2.t
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            ('a, 's) Monads.Std.Monad.Syntax.S2.t ->
            ('b, 's) Monads.Std.Monad.Syntax.S2.t ->
            ('c, 's) Monads.Std.Monad.Syntax.S2.t ->
            ('d, 's) Monads.Std.Monad.Syntax.S2.t ->
            ('e, 's) Monads.Std.Monad.Syntax.S2.t
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            ('a, 's) Monads.Std.Monad.Syntax.S2.t ->
            ('b, 's) Monads.Std.Monad.Syntax.S2.t ->
            ('c, 's) Monads.Std.Monad.Syntax.S2.t ->
            ('d, 's) Monads.Std.Monad.Syntax.S2.t ->
            ('e, 's) Monads.Std.Monad.Syntax.S2.t ->
            ('f, 's) Monads.Std.Monad.Syntax.S2.t
        end
    end
  module type S =
    sig
      type 'a t
      val void : 'Monads.Std.Monad.S.t -> unit Monads.Std.Monad.S.t
      val sequence :
        unit Monads.Std.Monad.S.t list -> unit Monads.Std.Monad.S.t
      val forever : 'Monads.Std.Monad.S.t -> 'Monads.Std.Monad.S.t
      module Fn :
        sig
          val id : '-> 'Monads.Std.Monad.S.t
          val ignore : 'Monads.Std.Monad.S.t -> unit Monads.Std.Monad.S.t
          val nothing : unit -> unit Monads.Std.Monad.S.t
          val non :
            ('-> bool Monads.Std.Monad.S.t) ->
            '-> bool Monads.Std.Monad.S.t
          val apply_n_times :
            n:int ->
            ('-> 'Monads.Std.Monad.S.t) -> '-> 'Monads.Std.Monad.S.t
          val compose :
            ('-> 'Monads.Std.Monad.S.t) ->
            ('-> 'Monads.Std.Monad.S.t) -> '-> 'Monads.Std.Monad.S.t
        end
      module Pair :
        sig
          val fst : ('a * 'b) Monads.Std.Monad.S.t -> 'Monads.Std.Monad.S.t
          val snd : ('a * 'b) Monads.Std.Monad.S.t -> 'Monads.Std.Monad.S.t
        end
      module Triple :
        sig
          val fst :
            ('a * 'b * 'c) Monads.Std.Monad.S.t -> 'Monads.Std.Monad.S.t
          val snd :
            ('a * 'b * 'c) Monads.Std.Monad.S.t -> 'Monads.Std.Monad.S.t
          val trd :
            ('a * 'b * 'c) Monads.Std.Monad.S.t -> 'Monads.Std.Monad.S.t
        end
      module Lift :
        sig
          val nullary : '-> 'Monads.Std.Monad.S.t
          val unary :
            ('-> 'b) -> 'Monads.Std.Monad.S.t -> 'Monads.Std.Monad.S.t
          val binary :
            ('-> '-> 'c) ->
            'Monads.Std.Monad.S.t ->
            'Monads.Std.Monad.S.t -> 'Monads.Std.Monad.S.t
          val ternary :
            ('-> '-> '-> 'd) ->
            'Monads.Std.Monad.S.t ->
            'Monads.Std.Monad.S.t ->
            'Monads.Std.Monad.S.t -> 'Monads.Std.Monad.S.t
          val quaternary :
            ('-> '-> '-> '-> 'e) ->
            'Monads.Std.Monad.S.t ->
            'Monads.Std.Monad.S.t ->
            'Monads.Std.Monad.S.t ->
            'Monads.Std.Monad.S.t -> 'Monads.Std.Monad.S.t
          val quinary :
            ('-> '-> '-> '-> '-> 'f) ->
            'Monads.Std.Monad.S.t ->
            'Monads.Std.Monad.S.t ->
            'Monads.Std.Monad.S.t ->
            'Monads.Std.Monad.S.t ->
            'Monads.Std.Monad.S.t -> 'Monads.Std.Monad.S.t
        end
      module Exn :
        sig
          val expect :
            ?finally:(unit -> unit Monads.Std.Monad.S.t) ->
            f:(unit -> 'Monads.Std.Monad.S.t) ->
            catch:(exn -> 'Monads.Std.Monad.S.t) -> 'Monads.Std.Monad.S.t
        end
      module Collection :
        sig
          module type S =
            sig
              type 'a t
              val all : 'a t t -> 'a t t
              val all_ignore : 'a t t -> unit t
              val sequence : unit t t -> unit t
              val map : 'a t -> f:('-> 'b t) -> 'b t t
              val iter : 'a t -> f:('-> unit t) -> unit t
              val fold : 'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_left : 'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_right :
                'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
              val reduce : 'a t -> f:('-> '-> 'a t) -> 'a option t
              val exists : 'a t -> f:('-> bool t) -> bool t
              val for_all : 'a t -> f:('-> bool t) -> bool t
              val count : 'a t -> f:('-> bool t) -> int t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'b t -> f:('-> 'a t) -> 'a t
              val find : 'a t -> f:('-> bool t) -> 'a option t
              val find_map : 'a t -> f:('-> 'b option t) -> 'b option t
              val filter : 'a t -> f:('-> bool t) -> 'a t t
              val filter_map : 'a t -> f:('-> 'b option t) -> 'b t t
            end
          module Eager :
            functor (T : Collection.Eager->
              sig
                val all : 'a t T.t -> 'T.t t
                val all_ignore : 'a t T.t -> unit t
                val sequence : unit t T.t -> unit t
                val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                val iter : 'T.t -> f:('-> unit t) -> unit t
                val fold : 'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                val fold_left :
                  'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                val fold_right :
                  'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                val reduce : 'T.t -> f:('-> '-> 'a t) -> 'a option t
                val exists : 'T.t -> f:('-> bool t) -> bool t
                val for_all : 'T.t -> f:('-> bool t) -> bool t
                val count : 'T.t -> f:('-> bool t) -> int t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'T.t -> f:('-> 'a t) -> 'a t
                val find : 'T.t -> f:('-> bool t) -> 'a option t
                val find_map : 'T.t -> f:('-> 'b option t) -> 'b option t
                val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                val filter_map : 'T.t -> f:('-> 'b option t) -> 'T.t t
              end
          module Delay :
            functor (T : Collection.Delay->
              sig
                val all : 'a t T.t -> 'T.t t
                val all_ignore : 'a t T.t -> unit t
                val sequence : unit t T.t -> unit t
                val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                val iter : 'T.t -> f:('-> unit t) -> unit t
                val fold : 'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                val fold_left :
                  'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                val fold_right :
                  'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                val reduce : 'T.t -> f:('-> '-> 'a t) -> 'a option t
                val exists : 'T.t -> f:('-> bool t) -> bool t
                val for_all : 'T.t -> f:('-> bool t) -> bool t
                val count : 'T.t -> f:('-> bool t) -> int t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'T.t -> f:('-> 'a t) -> 'a t
                val find : 'T.t -> f:('-> bool t) -> 'a option t
                val find_map : 'T.t -> f:('-> 'b option t) -> 'b option t
                val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                val filter_map : 'T.t -> f:('-> 'b option t) -> 'T.t t
              end
        end
      module List :
        sig
          val all : 'a t list -> 'a list t
          val all_ignore : 'a t list -> unit t
          val sequence : unit t list -> unit t
          val map : 'a list -> f:('-> 'b t) -> 'b list t
          val iter : 'a list -> f:('-> unit t) -> unit t
          val fold : 'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
          val fold_left : 'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
          val fold_right : 'a list -> f:('-> '-> 'b t) -> init:'-> 'b t
          val reduce : 'a list -> f:('-> '-> 'a t) -> 'a option t
          val exists : 'a list -> f:('-> bool t) -> bool t
          val for_all : 'a list -> f:('-> bool t) -> bool t
          val count : 'a list -> f:('-> bool t) -> int t
          val map_reduce :
            (module Monoid.S with type t = 'a) ->
            'b list -> f:('-> 'a t) -> 'a t
          val find : 'a list -> f:('-> bool t) -> 'a option t
          val find_map : 'a list -> f:('-> 'b option t) -> 'b option t
          val filter : 'a list -> f:('-> bool t) -> 'a list t
          val filter_map : 'a list -> f:('-> 'b option t) -> 'b list t
        end
      module Seq :
        sig
          val all :
            'a t Core_kernel.Std.Sequence.t ->
            'Core_kernel.Std.Sequence.t t
          val all_ignore : 'a t Core_kernel.Std.Sequence.t -> unit t
          val sequence : unit t Core_kernel.Std.Sequence.t -> unit t
          val map :
            'Core_kernel.Std.Sequence.t ->
            f:('-> 'b t) -> 'Core_kernel.Std.Sequence.t t
          val iter :
            'Core_kernel.Std.Sequence.t -> f:('-> unit t) -> unit t
          val fold :
            'Core_kernel.Std.Sequence.t ->
            init:'-> f:('-> '-> 'b t) -> 'b t
          val fold_left :
            'Core_kernel.Std.Sequence.t ->
            init:'-> f:('-> '-> 'b t) -> 'b t
          val fold_right :
            'Core_kernel.Std.Sequence.t ->
            f:('-> '-> 'b t) -> init:'-> 'b t
          val reduce :
            'Core_kernel.Std.Sequence.t ->
            f:('-> '-> 'a t) -> 'a option t
          val exists :
            'Core_kernel.Std.Sequence.t -> f:('-> bool t) -> bool t
          val for_all :
            'Core_kernel.Std.Sequence.t -> f:('-> bool t) -> bool t
          val count :
            'Core_kernel.Std.Sequence.t -> f:('-> bool t) -> int t
          val map_reduce :
            (module Monoid.S with type t = 'a) ->
            'Core_kernel.Std.Sequence.t -> f:('-> 'a t) -> 'a t
          val find :
            'Core_kernel.Std.Sequence.t -> f:('-> bool t) -> 'a option t
          val find_map :
            'Core_kernel.Std.Sequence.t ->
            f:('-> 'b option t) -> 'b option t
          val filter :
            'Core_kernel.Std.Sequence.t ->
            f:('-> bool t) -> 'Core_kernel.Std.Sequence.t t
          val filter_map :
            'Core_kernel.Std.Sequence.t ->
            f:('-> 'b option t) -> 'Core_kernel.Std.Sequence.t t
        end
      val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
      val ( !! ) : '-> 'a t
      val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
      val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
      val ( !$$$ ) : ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
      val ( !$$$$ ) :
        ('-> '-> '-> '-> 'e) -> 'a t -> 'b t -> 'c t -> 'd t -> 'e t
      val ( !$$$$$ ) :
        ('-> '-> '-> '-> '-> 'f) ->
        'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
      module Monad_infix :
        sig
          val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
          val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
        end
      val bind : 'a t -> f:('-> 'b t) -> 'b t
      val return : '-> 'a t
      val map : 'a t -> f:('-> 'b) -> 'b t
      val join : 'a t t -> 'a t
      val ignore_m : 'a t -> unit t
      val all : 'a t list -> 'a list t
      val all_ignore : unit t list -> unit t
      module Let_syntax :
        sig
          val return : '-> 'a t
          val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
          val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
          module Let_syntax :
            sig
              val return : '-> 'a t
              val bind : 'a t -> f:('-> 'b t) -> 'b t
              val map : 'a t -> f:('-> 'b) -> 'b t
              val both : 'a t -> 'b t -> ('a * 'b) t
              module Open_on_rhs : sig  end
            end
        end
      module Syntax :
        sig
          val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
          val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
          val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
          val ( !! ) : '-> 'a t
          val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
          val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
          val ( !$$$ ) :
            ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            'a t -> 'b t -> 'c t -> 'd t -> 'e t
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
        end
    end
  module type S2 =
    sig
      type ('a, 'e) t
      val void :
        ('a, 'e) Monads.Std.Monad.S2.t -> (unit, 'e) Monads.Std.Monad.S2.t
      val sequence :
        (unit, 'e) Monads.Std.Monad.S2.t list ->
        (unit, 'e) Monads.Std.Monad.S2.t
      val forever :
        ('a, 'e) Monads.Std.Monad.S2.t -> ('b, 'e) Monads.Std.Monad.S2.t
      module Fn :
        sig
          val id : '-> ('a, 'e) Monads.Std.Monad.S2.t
          val ignore :
            ('a, 'e) Monads.Std.Monad.S2.t ->
            (unit, 'e) Monads.Std.Monad.S2.t
          val nothing : unit -> (unit, 'e) Monads.Std.Monad.S2.t
          val non :
            ('-> (bool, 'e) Monads.Std.Monad.S2.t) ->
            '-> (bool, 'e) Monads.Std.Monad.S2.t
          val apply_n_times :
            n:int ->
            ('-> ('a, 'e) Monads.Std.Monad.S2.t) ->
            '-> ('a, 'e) Monads.Std.Monad.S2.t
          val compose :
            ('-> ('c, 'e) Monads.Std.Monad.S2.t) ->
            ('-> ('b, 'e) Monads.Std.Monad.S2.t) ->
            '-> ('c, 'e) Monads.Std.Monad.S2.t
        end
      module Pair :
        sig
          val fst :
            ('a * 'b, 'e) Monads.Std.Monad.S2.t ->
            ('a, 'e) Monads.Std.Monad.S2.t
          val snd :
            ('a * 'b, 'e) Monads.Std.Monad.S2.t ->
            ('b, 'e) Monads.Std.Monad.S2.t
        end
      module Triple :
        sig
          val fst :
            ('a * 'b * 'c, 'e) Monads.Std.Monad.S2.t ->
            ('a, 'e) Monads.Std.Monad.S2.t
          val snd :
            ('a * 'b * 'c, 'e) Monads.Std.Monad.S2.t ->
            ('b, 'e) Monads.Std.Monad.S2.t
          val trd :
            ('a * 'b * 'c, 'e) Monads.Std.Monad.S2.t ->
            ('c, 'e) Monads.Std.Monad.S2.t
        end
      module Lift :
        sig
          val nullary : '-> ('a, 'e) Monads.Std.Monad.S2.t
          val unary :
            ('-> 'b) ->
            ('a, 'e) Monads.Std.Monad.S2.t -> ('b, 'e) Monads.Std.Monad.S2.t
          val binary :
            ('-> '-> 'c) ->
            ('a, 'e) Monads.Std.Monad.S2.t ->
            ('b, 'e) Monads.Std.Monad.S2.t -> ('c, 'e) Monads.Std.Monad.S2.t
          val ternary :
            ('-> '-> '-> 'd) ->
            ('a, 'e) Monads.Std.Monad.S2.t ->
            ('b, 'e) Monads.Std.Monad.S2.t ->
            ('c, 'e) Monads.Std.Monad.S2.t -> ('d, 'e) Monads.Std.Monad.S2.t
          val quaternary :
            ('-> '-> '-> '-> 'e) ->
            ('a, 's) Monads.Std.Monad.S2.t ->
            ('b, 's) Monads.Std.Monad.S2.t ->
            ('c, 's) Monads.Std.Monad.S2.t ->
            ('d, 's) Monads.Std.Monad.S2.t -> ('e, 's) Monads.Std.Monad.S2.t
          val quinary :
            ('-> '-> '-> '-> '-> 'f) ->
            ('a, 's) Monads.Std.Monad.S2.t ->
            ('b, 's) Monads.Std.Monad.S2.t ->
            ('c, 's) Monads.Std.Monad.S2.t ->
            ('d, 's) Monads.Std.Monad.S2.t ->
            ('e, 's) Monads.Std.Monad.S2.t -> ('f, 's) Monads.Std.Monad.S2.t
        end
      module Exn :
        sig
          val expect :
            ?finally:(unit -> (unit, 's) Monads.Std.Monad.S2.t) ->
            f:(unit -> ('a, 's) Monads.Std.Monad.S2.t) ->
            catch:(exn -> ('a, 's) Monads.Std.Monad.S2.t) ->
            ('a, 's) Monads.Std.Monad.S2.t
        end
      module Collection :
        sig
          module type S =
            sig
              type 'a t
              val all : ('a, 'e) t t -> ('a t, 'e) t
              val all_ignore : ('a, 'e) t t -> (unit, 'e) t
              val sequence : (unit, 'e) t t -> (unit, 'e) t
              val map : 'a t -> f:('-> ('b, 'e) t) -> ('b t, 'e) t
              val iter : 'a t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
              val fold :
                'a t -> init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_left :
                'a t -> init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_right :
                'a t -> f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
              val reduce :
                'a t -> f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
              val exists : 'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val for_all : 'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val count : 'a t -> f:('-> (bool, 'e) t) -> (int, 'e) t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'b t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
              val find : 'a t -> f:('-> (bool, 'e) t) -> ('a option, 'e) t
              val find_map :
                'a t -> f:('-> ('b option, 'e) t) -> ('b option, 'e) t
              val filter : 'a t -> f:('-> (bool, 'e) t) -> ('a t, 'e) t
              val filter_map :
                'a t -> f:('-> ('b option, 'e) t) -> ('b t, 'e) t
            end
          module Eager :
            functor (T : Collection.Eager->
              sig
                val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                val all_ignore : ('a, 'e) t T.t -> (unit, 'e) t
                val sequence : (unit, 'e) t T.t -> (unit, 'e) t
                val map : 'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                val iter : 'T.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                val fold :
                  'T.t ->
                  init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                val fold_left :
                  'T.t ->
                  init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                val fold_right :
                  'T.t ->
                  f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                val reduce :
                  'T.t -> f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                val exists : 'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                val for_all :
                  'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                val count : 'T.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                val find :
                  'T.t -> f:('-> (bool, 'e) t) -> ('a option, 'e) t
                val find_map :
                  'T.t -> f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                val filter :
                  'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                val filter_map :
                  'T.t -> f:('-> ('b option, 'e) t) -> ('T.t, 'e) t
              end
          module Delay :
            functor (T : Collection.Delay->
              sig
                val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                val all_ignore : ('a, 'e) t T.t -> (unit, 'e) t
                val sequence : (unit, 'e) t T.t -> (unit, 'e) t
                val map : 'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                val iter : 'T.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                val fold :
                  'T.t ->
                  init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                val fold_left :
                  'T.t ->
                  init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                val fold_right :
                  'T.t ->
                  f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                val reduce :
                  'T.t -> f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                val exists : 'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                val for_all :
                  'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                val count : 'T.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                val find :
                  'T.t -> f:('-> (bool, 'e) t) -> ('a option, 'e) t
                val find_map :
                  'T.t -> f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                val filter :
                  'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                val filter_map :
                  'T.t -> f:('-> ('b option, 'e) t) -> ('T.t, 'e) t
              end
        end
      module List :
        sig
          val all : ('a, 'e) t list -> ('a list, 'e) t
          val all_ignore : ('a, 'e) t list -> (unit, 'e) t
          val sequence : (unit, 'e) t list -> (unit, 'e) t
          val map : 'a list -> f:('-> ('b, 'e) t) -> ('b list, 'e) t
          val iter : 'a list -> f:('-> (unit, 'e) t) -> (unit, 'e) t
          val fold :
            'a list -> init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
          val fold_left :
            'a list -> init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
          val fold_right :
            'a list -> f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
          val reduce :
            'a list -> f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
          val exists : 'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t
          val for_all : 'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t
          val count : 'a list -> f:('-> (bool, 'e) t) -> (int, 'e) t
          val map_reduce :
            (module Monoid.S with type t = 'a) ->
            'b list -> f:('-> ('a, 'e) t) -> ('a, 'e) t
          val find : 'a list -> f:('-> (bool, 'e) t) -> ('a option, 'e) t
          val find_map :
            'a list -> f:('-> ('b option, 'e) t) -> ('b option, 'e) t
          val filter : 'a list -> f:('-> (bool, 'e) t) -> ('a list, 'e) t
          val filter_map :
            'a list -> f:('-> ('b option, 'e) t) -> ('b list, 'e) t
        end
      module Seq :
        sig
          val all :
            ('a, 'e) t Core_kernel.Std.Sequence.t ->
            ('Core_kernel.Std.Sequence.t, 'e) t
          val all_ignore :
            ('a, 'e) t Core_kernel.Std.Sequence.t -> (unit, 'e) t
          val sequence :
            (unit, 'e) t Core_kernel.Std.Sequence.t -> (unit, 'e) t
          val map :
            'Core_kernel.Std.Sequence.t ->
            f:('-> ('b, 'e) t) -> ('Core_kernel.Std.Sequence.t, 'e) t
          val iter :
            'Core_kernel.Std.Sequence.t ->
            f:('-> (unit, 'e) t) -> (unit, 'e) t
          val fold :
            'Core_kernel.Std.Sequence.t ->
            init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
          val fold_left :
            'Core_kernel.Std.Sequence.t ->
            init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
          val fold_right :
            'Core_kernel.Std.Sequence.t ->
            f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
          val reduce :
            'Core_kernel.Std.Sequence.t ->
            f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
          val exists :
            'Core_kernel.Std.Sequence.t ->
            f:('-> (bool, 'e) t) -> (bool, 'e) t
          val for_all :
            'Core_kernel.Std.Sequence.t ->
            f:('-> (bool, 'e) t) -> (bool, 'e) t
          val count :
            'Core_kernel.Std.Sequence.t ->
            f:('-> (bool, 'e) t) -> (int, 'e) t
          val map_reduce :
            (module Monoid.S with type t = 'a) ->
            'Core_kernel.Std.Sequence.t ->
            f:('-> ('a, 'e) t) -> ('a, 'e) t
          val find :
            'Core_kernel.Std.Sequence.t ->
            f:('-> (bool, 'e) t) -> ('a option, 'e) t
          val find_map :
            'Core_kernel.Std.Sequence.t ->
            f:('-> ('b option, 'e) t) -> ('b option, 'e) t
          val filter :
            'Core_kernel.Std.Sequence.t ->
            f:('-> (bool, 'e) t) -> ('Core_kernel.Std.Sequence.t, 'e) t
          val filter_map :
            'Core_kernel.Std.Sequence.t ->
            f:('-> ('b option, 'e) t) ->
            ('Core_kernel.Std.Sequence.t, 'e) t
        end
      val ( >=> ) :
        ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
      val ( !! ) : '-> ('a, 'e) t
      val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
      val ( !$$ ) :
        ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
      val ( !$$$ ) :
        ('-> '-> '-> 'd) ->
        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
      val ( !$$$$ ) :
        ('-> '-> '-> '-> 'e) ->
        ('a, 's) t -> ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
      val ( !$$$$$ ) :
        ('-> '-> '-> '-> '-> 'f) ->
        ('a, 's) t ->
        ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
      val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
      module Let_syntax :
        sig
          val return : '-> ('a, 'b) t
          val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
          val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
          module Let_syntax :
            sig
              val return : '-> ('a, 'b) t
              val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
              val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
              val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
              module Open_on_rhs : sig  end
            end
        end
      module Monad_infix :
        sig
          val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
          val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
        end
      val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
      val return : '-> ('a, 'b) t
      val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
      val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
      val ignore_m : ('a, 'e) t -> (unit, 'e) t
      val all : ('a, 'e) t list -> ('a list, 'e) t
      val all_ignore : (unit, 'e) t list -> (unit, 'e) t
      module Syntax :
        sig
          val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
          val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
          val ( >=> ) :
            ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
          val ( !! ) : '-> ('a, 'e) t
          val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
          val ( !$$ ) :
            ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
          val ( !$$$ ) :
            ('-> '-> '-> 'd) ->
            ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            ('a, 's) t ->
            ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            ('a, 's) t ->
            ('b, 's) t ->
            ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
        end
    end
  module type Core = Core_kernel.Std.Monad.S
  module type Core2 = Core_kernel.Std.Monad.S2
  module type Minimal =
    sig
      type 'a t
      val return : '-> 'Monads.Std.Monad.Minimal.t
      val bind :
        'Monads.Std.Monad.Minimal.t ->
        ('-> 'Monads.Std.Monad.Minimal.t) ->
        'Monads.Std.Monad.Minimal.t
    end
  module type Minimal2 =
    sig
      type ('a, 'e) t
      val return : '-> ('a, 'e) Monads.Std.Monad.Minimal2.t
      val bind :
        ('a, 'e) Monads.Std.Monad.Minimal2.t ->
        ('-> ('b, 'e) Monads.Std.Monad.Minimal2.t) ->
        ('b, 'e) Monads.Std.Monad.Minimal2.t
    end
  module Make :
    functor (M : Basic->
      sig
        val void : 'M.t -> unit M.t
        val sequence : unit M.t list -> unit M.t
        val forever : 'M.t -> 'M.t
        module Fn :
          sig
            val id : '-> 'M.t
            val ignore : 'M.t -> unit M.t
            val nothing : unit -> unit M.t
            val non : ('-> bool M.t) -> '-> bool M.t
            val apply_n_times : n:int -> ('-> 'M.t) -> '-> 'M.t
            val compose : ('-> 'M.t) -> ('-> 'M.t) -> '-> 'M.t
          end
        module Pair :
          sig
            val fst : ('a * 'b) M.t -> 'M.t
            val snd : ('a * 'b) M.t -> 'M.t
          end
        module Triple :
          sig
            val fst : ('a * 'b * 'c) M.t -> 'M.t
            val snd : ('a * 'b * 'c) M.t -> 'M.t
            val trd : ('a * 'b * 'c) M.t -> 'M.t
          end
        module Lift :
          sig
            val nullary : '-> 'M.t
            val unary : ('-> 'b) -> 'M.t -> 'M.t
            val binary : ('-> '-> 'c) -> 'M.t -> 'M.t -> 'M.t
            val ternary :
              ('-> '-> '-> 'd) -> 'M.t -> 'M.t -> 'M.t -> 'M.t
            val quaternary :
              ('-> '-> '-> '-> 'e) ->
              'M.t -> 'M.t -> 'M.t -> 'M.t -> 'M.t
            val quinary :
              ('-> '-> '-> '-> '-> 'f) ->
              'M.t -> 'M.t -> 'M.t -> 'M.t -> 'M.t -> 'M.t
          end
        module Exn :
          sig
            val expect :
              ?finally:(unit -> unit M.t) ->
              f:(unit -> 'M.t) -> catch:(exn -> 'M.t) -> 'M.t
          end
        module Collection :
          sig
            module type S =
              sig
                type 'a t
                val all : 'M.t t -> 'a t M.t
                val all_ignore : 'M.t t -> unit M.t
                val sequence : unit M.t t -> unit M.t
                val map : 'a t -> f:('-> 'M.t) -> 'b t M.t
                val iter : 'a t -> f:('-> unit M.t) -> unit M.t
                val fold :
                  'a t -> init:'-> f:('-> '-> 'M.t) -> 'M.t
                val fold_left :
                  'a t -> init:'-> f:('-> '-> 'M.t) -> 'M.t
                val fold_right :
                  'a t -> f:('-> '-> 'M.t) -> init:'-> 'M.t
                val reduce : 'a t -> f:('-> '-> 'M.t) -> 'a option M.t
                val exists : 'a t -> f:('-> bool M.t) -> bool M.t
                val for_all : 'a t -> f:('-> bool M.t) -> bool M.t
                val count : 'a t -> f:('-> bool M.t) -> int M.t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'b t -> f:('-> 'M.t) -> 'M.t
                val find : 'a t -> f:('-> bool M.t) -> 'a option M.t
                val find_map :
                  'a t -> f:('-> 'b option M.t) -> 'b option M.t
                val filter : 'a t -> f:('-> bool M.t) -> 'a t M.t
                val filter_map : 'a t -> f:('-> 'b option M.t) -> 'b t M.t
              end
            module Eager :
              functor (T : Collection.Eager->
                sig
                  val all : 'M.t T.t -> 'T.t M.t
                  val all_ignore : 'M.t T.t -> unit M.t
                  val sequence : unit M.t T.t -> unit M.t
                  val map : 'T.t -> f:('-> 'M.t) -> 'T.t M.t
                  val iter : 'T.t -> f:('-> unit M.t) -> unit M.t
                  val fold :
                    'T.t -> init:'-> f:('-> '-> 'M.t) -> 'M.t
                  val fold_left :
                    'T.t -> init:'-> f:('-> '-> 'M.t) -> 'M.t
                  val fold_right :
                    'T.t -> f:('-> '-> 'M.t) -> init:'-> 'M.t
                  val reduce :
                    'T.t -> f:('-> '-> 'M.t) -> 'a option M.t
                  val exists : 'T.t -> f:('-> bool M.t) -> bool M.t
                  val for_all : 'T.t -> f:('-> bool M.t) -> bool M.t
                  val count : 'T.t -> f:('-> bool M.t) -> int M.t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'T.t -> f:('-> 'M.t) -> 'M.t
                  val find : 'T.t -> f:('-> bool M.t) -> 'a option M.t
                  val find_map :
                    'T.t -> f:('-> 'b option M.t) -> 'b option M.t
                  val filter : 'T.t -> f:('-> bool M.t) -> 'T.t M.t
                  val filter_map :
                    'T.t -> f:('-> 'b option M.t) -> 'T.t M.t
                end
            module Delay :
              functor (T : Collection.Delay->
                sig
                  val all : 'M.t T.t -> 'T.t M.t
                  val all_ignore : 'M.t T.t -> unit M.t
                  val sequence : unit M.t T.t -> unit M.t
                  val map : 'T.t -> f:('-> 'M.t) -> 'T.t M.t
                  val iter : 'T.t -> f:('-> unit M.t) -> unit M.t
                  val fold :
                    'T.t -> init:'-> f:('-> '-> 'M.t) -> 'M.t
                  val fold_left :
                    'T.t -> init:'-> f:('-> '-> 'M.t) -> 'M.t
                  val fold_right :
                    'T.t -> f:('-> '-> 'M.t) -> init:'-> 'M.t
                  val reduce :
                    'T.t -> f:('-> '-> 'M.t) -> 'a option M.t
                  val exists : 'T.t -> f:('-> bool M.t) -> bool M.t
                  val for_all : 'T.t -> f:('-> bool M.t) -> bool M.t
                  val count : 'T.t -> f:('-> bool M.t) -> int M.t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'T.t -> f:('-> 'M.t) -> 'M.t
                  val find : 'T.t -> f:('-> bool M.t) -> 'a option M.t
                  val find_map :
                    'T.t -> f:('-> 'b option M.t) -> 'b option M.t
                  val filter : 'T.t -> f:('-> bool M.t) -> 'T.t M.t
                  val filter_map :
                    'T.t -> f:('-> 'b option M.t) -> 'T.t M.t
                end
          end
        module List :
          sig
            val all : 'M.t list -> 'a list M.t
            val all_ignore : 'M.t list -> unit M.t
            val sequence : unit M.t list -> unit M.t
            val map : 'a list -> f:('-> 'M.t) -> 'b list M.t
            val iter : 'a list -> f:('-> unit M.t) -> unit M.t
            val fold : 'a list -> init:'-> f:('-> '-> 'M.t) -> 'M.t
            val fold_left :
              'a list -> init:'-> f:('-> '-> 'M.t) -> 'M.t
            val fold_right :
              'a list -> f:('-> '-> 'M.t) -> init:'-> 'M.t
            val reduce : 'a list -> f:('-> '-> 'M.t) -> 'a option M.t
            val exists : 'a list -> f:('-> bool M.t) -> bool M.t
            val for_all : 'a list -> f:('-> bool M.t) -> bool M.t
            val count : 'a list -> f:('-> bool M.t) -> int M.t
            val map_reduce :
              (module Monoid.S with type t = 'a) ->
              'b list -> f:('-> 'M.t) -> 'M.t
            val find : 'a list -> f:('-> bool M.t) -> 'a option M.t
            val find_map :
              'a list -> f:('-> 'b option M.t) -> 'b option M.t
            val filter : 'a list -> f:('-> bool M.t) -> 'a list M.t
            val filter_map :
              'a list -> f:('-> 'b option M.t) -> 'b list M.t
          end
        module Seq :
          sig
            val all :
              'M.t Core_kernel.Std.Sequence.t ->
              'Core_kernel.Std.Sequence.t M.t
            val all_ignore : 'M.t Core_kernel.Std.Sequence.t -> unit M.t
            val sequence : unit M.t Core_kernel.Std.Sequence.t -> unit M.t
            val map :
              'Core_kernel.Std.Sequence.t ->
              f:('-> 'M.t) -> 'Core_kernel.Std.Sequence.t M.t
            val iter :
              'Core_kernel.Std.Sequence.t -> f:('-> unit M.t) -> unit M.t
            val fold :
              'Core_kernel.Std.Sequence.t ->
              init:'-> f:('-> '-> 'M.t) -> 'M.t
            val fold_left :
              'Core_kernel.Std.Sequence.t ->
              init:'-> f:('-> '-> 'M.t) -> 'M.t
            val fold_right :
              'Core_kernel.Std.Sequence.t ->
              f:('-> '-> 'M.t) -> init:'-> 'M.t
            val reduce :
              'Core_kernel.Std.Sequence.t ->
              f:('-> '-> 'M.t) -> 'a option M.t
            val exists :
              'Core_kernel.Std.Sequence.t -> f:('-> bool M.t) -> bool M.t
            val for_all :
              'Core_kernel.Std.Sequence.t -> f:('-> bool M.t) -> bool M.t
            val count :
              'Core_kernel.Std.Sequence.t -> f:('-> bool M.t) -> int M.t
            val map_reduce :
              (module Monoid.S with type t = 'a) ->
              'Core_kernel.Std.Sequence.t -> f:('-> 'M.t) -> 'M.t
            val find :
              'Core_kernel.Std.Sequence.t ->
              f:('-> bool M.t) -> 'a option M.t
            val find_map :
              'Core_kernel.Std.Sequence.t ->
              f:('-> 'b option M.t) -> 'b option M.t
            val filter :
              'Core_kernel.Std.Sequence.t ->
              f:('-> bool M.t) -> 'Core_kernel.Std.Sequence.t M.t
            val filter_map :
              'Core_kernel.Std.Sequence.t ->
              f:('-> 'b option M.t) -> 'Core_kernel.Std.Sequence.t M.t
          end
        val ( >=> ) : ('-> 'M.t) -> ('-> 'M.t) -> '-> 'M.t
        val ( !! ) : '-> 'M.t
        val ( !$ ) : ('-> 'b) -> 'M.t -> 'M.t
        val ( !$$ ) : ('-> '-> 'c) -> 'M.t -> 'M.t -> 'M.t
        val ( !$$$ ) :
          ('-> '-> '-> 'd) -> 'M.t -> 'M.t -> 'M.t -> 'M.t
        val ( !$$$$ ) :
          ('-> '-> '-> '-> 'e) ->
          'M.t -> 'M.t -> 'M.t -> 'M.t -> 'M.t
        val ( !$$$$$ ) :
          ('-> '-> '-> '-> '-> 'f) ->
          'M.t -> 'M.t -> 'M.t -> 'M.t -> 'M.t -> 'M.t
        val ( >>= ) : 'M.t -> ('-> 'M.t) -> 'M.t
        val ( >>| ) : 'M.t -> ('-> 'b) -> 'M.t
        module Monad_infix :
          sig
            val ( >>= ) : 'M.t -> ('-> 'M.t) -> 'M.t
            val ( >>| ) : 'M.t -> ('-> 'b) -> 'M.t
          end
        val bind : 'M.t -> f:('-> 'M.t) -> 'M.t
        val return : '-> 'M.t
        val map : 'M.t -> f:('-> 'b) -> 'M.t
        val join : 'M.t M.t -> 'M.t
        val ignore_m : 'M.t -> unit M.t
        val all : 'M.t list -> 'a list M.t
        val all_ignore : unit M.t list -> unit M.t
        module Let_syntax :
          sig
            val return : '-> 'M.t
            val ( >>= ) : 'M.t -> ('-> 'M.t) -> 'M.t
            val ( >>| ) : 'M.t -> ('-> 'b) -> 'M.t
            module Let_syntax :
              sig
                val return : '-> 'M.t
                val bind : 'M.t -> f:('-> 'M.t) -> 'M.t
                val map : 'M.t -> f:('-> 'b) -> 'M.t
                val both : 'M.t -> 'M.t -> ('a * 'b) M.t
                module Open_on_rhs : sig  end
              end
          end
        module Syntax :
          sig
            val ( >>= ) : 'M.t -> ('-> 'M.t) -> 'M.t
            val ( >>| ) : 'M.t -> ('-> 'b) -> 'M.t
            val ( >=> ) : ('-> 'M.t) -> ('-> 'M.t) -> '-> 'M.t
            val ( !! ) : '-> 'M.t
            val ( !$ ) : ('-> 'b) -> 'M.t -> 'M.t
            val ( !$$ ) : ('-> '-> 'c) -> 'M.t -> 'M.t -> 'M.t
            val ( !$$$ ) :
              ('-> '-> '-> 'd) -> 'M.t -> 'M.t -> 'M.t -> 'M.t
            val ( !$$$$ ) :
              ('-> '-> '-> '-> 'e) ->
              'M.t -> 'M.t -> 'M.t -> 'M.t -> 'M.t
            val ( !$$$$$ ) :
              ('-> '-> '-> '-> '-> 'f) ->
              'M.t -> 'M.t -> 'M.t -> 'M.t -> 'M.t -> 'M.t
          end
      end
  module Make2 :
    functor (M : Basic2->
      sig
        val void : ('a, 'e) M.t -> (unit, 'e) M.t
        val sequence : (unit, 'e) M.t list -> (unit, 'e) M.t
        val forever : ('a, 'e) M.t -> ('b, 'e) M.t
        module Fn :
          sig
            val id : '-> ('a, 'e) M.t
            val ignore : ('a, 'e) M.t -> (unit, 'e) M.t
            val nothing : unit -> (unit, 'e) M.t
            val non : ('-> (bool, 'e) M.t) -> '-> (bool, 'e) M.t
            val apply_n_times :
              n:int -> ('-> ('a, 'e) M.t) -> '-> ('a, 'e) M.t
            val compose :
              ('-> ('c, 'e) M.t) ->
              ('-> ('b, 'e) M.t) -> '-> ('c, 'e) M.t
          end
        module Pair :
          sig
            val fst : ('a * 'b, 'e) M.t -> ('a, 'e) M.t
            val snd : ('a * 'b, 'e) M.t -> ('b, 'e) M.t
          end
        module Triple :
          sig
            val fst : ('a * 'b * 'c, 'e) M.t -> ('a, 'e) M.t
            val snd : ('a * 'b * 'c, 'e) M.t -> ('b, 'e) M.t
            val trd : ('a * 'b * 'c, 'e) M.t -> ('c, 'e) M.t
          end
        module Lift :
          sig
            val nullary : '-> ('a, 'e) M.t
            val unary : ('-> 'b) -> ('a, 'e) M.t -> ('b, 'e) M.t
            val binary :
              ('-> '-> 'c) ->
              ('a, 'e) M.t -> ('b, 'e) M.t -> ('c, 'e) M.t
            val ternary :
              ('-> '-> '-> 'd) ->
              ('a, 'e) M.t -> ('b, 'e) M.t -> ('c, 'e) M.t -> ('d, 'e) M.t
            val quaternary :
              ('-> '-> '-> '-> 'e) ->
              ('a, 's) M.t ->
              ('b, 's) M.t -> ('c, 's) M.t -> ('d, 's) M.t -> ('e, 's) M.t
            val quinary :
              ('-> '-> '-> '-> '-> 'f) ->
              ('a, 's) M.t ->
              ('b, 's) M.t ->
              ('c, 's) M.t -> ('d, 's) M.t -> ('e, 's) M.t -> ('f, 's) M.t
          end
        module Exn :
          sig
            val expect :
              ?finally:(unit -> (unit, 's) M.t) ->
              f:(unit -> ('a, 's) M.t) ->
              catch:(exn -> ('a, 's) M.t) -> ('a, 's) M.t
          end
        module Collection :
          sig
            module type S =
              sig
                type 'a t
                val all : ('a, 'e) M.t t -> ('a t, 'e) M.t
                val all_ignore : ('a, 'e) M.t t -> (unit, 'e) M.t
                val sequence : (unit, 'e) M.t t -> (unit, 'e) M.t
                val map : 'a t -> f:('-> ('b, 'e) M.t) -> ('b t, 'e) M.t
                val iter : 'a t -> f:('-> (unit, 'e) M.t) -> (unit, 'e) M.t
                val fold :
                  'a t ->
                  init:'-> f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
                val fold_left :
                  'a t ->
                  init:'-> f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
                val fold_right :
                  'a t ->
                  f:('-> '-> ('b, 'e) M.t) -> init:'-> ('b, 'e) M.t
                val reduce :
                  'a t -> f:('-> '-> ('a, 'e) M.t) -> ('a option, 'e) M.t
                val exists :
                  'a t -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
                val for_all :
                  'a t -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
                val count : 'a t -> f:('-> (bool, 'e) M.t) -> (int, 'e) M.t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'b t -> f:('-> ('a, 'e) M.t) -> ('a, 'e) M.t
                val find :
                  'a t -> f:('-> (bool, 'e) M.t) -> ('a option, 'e) M.t
                val find_map :
                  'a t ->
                  f:('-> ('b option, 'e) M.t) -> ('b option, 'e) M.t
                val filter :
                  'a t -> f:('-> (bool, 'e) M.t) -> ('a t, 'e) M.t
                val filter_map :
                  'a t -> f:('-> ('b option, 'e) M.t) -> ('b t, 'e) M.t
              end
            module Eager :
              functor (T : Collection.Eager->
                sig
                  val all : ('a, 'e) M.t T.t -> ('T.t, 'e) M.t
                  val all_ignore : ('a, 'e) M.t T.t -> (unit, 'e) M.t
                  val sequence : (unit, 'e) M.t T.t -> (unit, 'e) M.t
                  val map :
                    'T.t -> f:('-> ('b, 'e) M.t) -> ('T.t, 'e) M.t
                  val iter :
                    'T.t -> f:('-> (unit, 'e) M.t) -> (unit, 'e) M.t
                  val fold :
                    'T.t ->
                    init:'-> f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
                  val fold_left :
                    'T.t ->
                    init:'-> f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
                  val fold_right :
                    'T.t ->
                    f:('-> '-> ('b, 'e) M.t) -> init:'-> ('b, 'e) M.t
                  val reduce :
                    'T.t ->
                    f:('-> '-> ('a, 'e) M.t) -> ('a option, 'e) M.t
                  val exists :
                    'T.t -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
                  val for_all :
                    'T.t -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
                  val count :
                    'T.t -> f:('-> (bool, 'e) M.t) -> (int, 'e) M.t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'T.t -> f:('-> ('a, 'e) M.t) -> ('a, 'e) M.t
                  val find :
                    'T.t -> f:('-> (bool, 'e) M.t) -> ('a option, 'e) M.t
                  val find_map :
                    'T.t ->
                    f:('-> ('b option, 'e) M.t) -> ('b option, 'e) M.t
                  val filter :
                    'T.t -> f:('-> (bool, 'e) M.t) -> ('T.t, 'e) M.t
                  val filter_map :
                    'T.t ->
                    f:('-> ('b option, 'e) M.t) -> ('T.t, 'e) M.t
                end
            module Delay :
              functor (T : Collection.Delay->
                sig
                  val all : ('a, 'e) M.t T.t -> ('T.t, 'e) M.t
                  val all_ignore : ('a, 'e) M.t T.t -> (unit, 'e) M.t
                  val sequence : (unit, 'e) M.t T.t -> (unit, 'e) M.t
                  val map :
                    'T.t -> f:('-> ('b, 'e) M.t) -> ('T.t, 'e) M.t
                  val iter :
                    'T.t -> f:('-> (unit, 'e) M.t) -> (unit, 'e) M.t
                  val fold :
                    'T.t ->
                    init:'-> f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
                  val fold_left :
                    'T.t ->
                    init:'-> f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
                  val fold_right :
                    'T.t ->
                    f:('-> '-> ('b, 'e) M.t) -> init:'-> ('b, 'e) M.t
                  val reduce :
                    'T.t ->
                    f:('-> '-> ('a, 'e) M.t) -> ('a option, 'e) M.t
                  val exists :
                    'T.t -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
                  val for_all :
                    'T.t -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
                  val count :
                    'T.t -> f:('-> (bool, 'e) M.t) -> (int, 'e) M.t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'T.t -> f:('-> ('a, 'e) M.t) -> ('a, 'e) M.t
                  val find :
                    'T.t -> f:('-> (bool, 'e) M.t) -> ('a option, 'e) M.t
                  val find_map :
                    'T.t ->
                    f:('-> ('b option, 'e) M.t) -> ('b option, 'e) M.t
                  val filter :
                    'T.t -> f:('-> (bool, 'e) M.t) -> ('T.t, 'e) M.t
                  val filter_map :
                    'T.t ->
                    f:('-> ('b option, 'e) M.t) -> ('T.t, 'e) M.t
                end
          end
        module List :
          sig
            val all : ('a, 'e) M.t list -> ('a list, 'e) M.t
            val all_ignore : ('a, 'e) M.t list -> (unit, 'e) M.t
            val sequence : (unit, 'e) M.t list -> (unit, 'e) M.t
            val map : 'a list -> f:('-> ('b, 'e) M.t) -> ('b list, 'e) M.t
            val iter : 'a list -> f:('-> (unit, 'e) M.t) -> (unit, 'e) M.t
            val fold :
              'a list ->
              init:'-> f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
            val fold_left :
              'a list ->
              init:'-> f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
            val fold_right :
              'a list ->
              f:('-> '-> ('b, 'e) M.t) -> init:'-> ('b, 'e) M.t
            val reduce :
              'a list -> f:('-> '-> ('a, 'e) M.t) -> ('a option, 'e) M.t
            val exists :
              'a list -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
            val for_all :
              'a list -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
            val count : 'a list -> f:('-> (bool, 'e) M.t) -> (int, 'e) M.t
            val map_reduce :
              (module Monoid.S with type t = 'a) ->
              'b list -> f:('-> ('a, 'e) M.t) -> ('a, 'e) M.t
            val find :
              'a list -> f:('-> (bool, 'e) M.t) -> ('a option, 'e) M.t
            val find_map :
              'a list -> f:('-> ('b option, 'e) M.t) -> ('b option, 'e) M.t
            val filter :
              'a list -> f:('-> (bool, 'e) M.t) -> ('a list, 'e) M.t
            val filter_map :
              'a list -> f:('-> ('b option, 'e) M.t) -> ('b list, 'e) M.t
          end
        module Seq :
          sig
            val all :
              ('a, 'e) M.t Core_kernel.Std.Sequence.t ->
              ('Core_kernel.Std.Sequence.t, 'e) M.t
            val all_ignore :
              ('a, 'e) M.t Core_kernel.Std.Sequence.t -> (unit, 'e) M.t
            val sequence :
              (unit, 'e) M.t Core_kernel.Std.Sequence.t -> (unit, 'e) M.t
            val map :
              'Core_kernel.Std.Sequence.t ->
              f:('-> ('b, 'e) M.t) ->
              ('Core_kernel.Std.Sequence.t, 'e) M.t
            val iter :
              'Core_kernel.Std.Sequence.t ->
              f:('-> (unit, 'e) M.t) -> (unit, 'e) M.t
            val fold :
              'Core_kernel.Std.Sequence.t ->
              init:'-> f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
            val fold_left :
              'Core_kernel.Std.Sequence.t ->
              init:'-> f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
            val fold_right :
              'Core_kernel.Std.Sequence.t ->
              f:('-> '-> ('b, 'e) M.t) -> init:'-> ('b, 'e) M.t
            val reduce :
              'Core_kernel.Std.Sequence.t ->
              f:('-> '-> ('a, 'e) M.t) -> ('a option, 'e) M.t
            val exists :
              'Core_kernel.Std.Sequence.t ->
              f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
            val for_all :
              'Core_kernel.Std.Sequence.t ->
              f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
            val count :
              'Core_kernel.Std.Sequence.t ->
              f:('-> (bool, 'e) M.t) -> (int, 'e) M.t
            val map_reduce :
              (module Monoid.S with type t = 'a) ->
              'Core_kernel.Std.Sequence.t ->
              f:('-> ('a, 'e) M.t) -> ('a, 'e) M.t
            val find :
              'Core_kernel.Std.Sequence.t ->
              f:('-> (bool, 'e) M.t) -> ('a option, 'e) M.t
            val find_map :
              'Core_kernel.Std.Sequence.t ->
              f:('-> ('b option, 'e) M.t) -> ('b option, 'e) M.t
            val filter :
              'Core_kernel.Std.Sequence.t ->
              f:('-> (bool, 'e) M.t) ->
              ('Core_kernel.Std.Sequence.t, 'e) M.t
            val filter_map :
              'Core_kernel.Std.Sequence.t ->
              f:('-> ('b option, 'e) M.t) ->
              ('Core_kernel.Std.Sequence.t, 'e) M.t
          end
        val ( >=> ) :
          ('-> ('b, 'e) M.t) -> ('-> ('c, 'e) M.t) -> '-> ('c, 'e) M.t
        val ( !! ) : '-> ('a, 'e) M.t
        val ( !$ ) : ('-> 'b) -> ('a, 'e) M.t -> ('b, 'e) M.t
        val ( !$$ ) :
          ('-> '-> 'c) -> ('a, 'e) M.t -> ('b, 'e) M.t -> ('c, 'e) M.t
        val ( !$$$ ) :
          ('-> '-> '-> 'd) ->
          ('a, 'e) M.t -> ('b, 'e) M.t -> ('c, 'e) M.t -> ('d, 'e) M.t
        val ( !$$$$ ) :
          ('-> '-> '-> '-> 'e) ->
          ('a, 's) M.t ->
          ('b, 's) M.t -> ('c, 's) M.t -> ('d, 's) M.t -> ('e, 's) M.t
        val ( !$$$$$ ) :
          ('-> '-> '-> '-> '-> 'f) ->
          ('a, 's) M.t ->
          ('b, 's) M.t ->
          ('c, 's) M.t -> ('d, 's) M.t -> ('e, 's) M.t -> ('f, 's) M.t
        val ( >>= ) : ('a, 'e) M.t -> ('-> ('b, 'e) M.t) -> ('b, 'e) M.t
        val ( >>| ) : ('a, 'e) M.t -> ('-> 'b) -> ('b, 'e) M.t
        module Let_syntax :
          sig
            val return : '-> ('a, 'b) M.t
            val ( >>= ) :
              ('a, 'e) M.t -> ('-> ('b, 'e) M.t) -> ('b, 'e) M.t
            val ( >>| ) : ('a, 'e) M.t -> ('-> 'b) -> ('b, 'e) M.t
            module Let_syntax :
              sig
                val return : '-> ('a, 'b) M.t
                val bind :
                  ('a, 'e) M.t -> f:('-> ('b, 'e) M.t) -> ('b, 'e) M.t
                val map : ('a, 'e) M.t -> f:('-> 'b) -> ('b, 'e) M.t
                val both : ('a, 'e) M.t -> ('b, 'e) M.t -> ('a * 'b, 'e) M.t
                module Open_on_rhs : sig  end
              end
          end
        module Monad_infix :
          sig
            val ( >>= ) :
              ('a, 'e) M.t -> ('-> ('b, 'e) M.t) -> ('b, 'e) M.t
            val ( >>| ) : ('a, 'e) M.t -> ('-> 'b) -> ('b, 'e) M.t
          end
        val bind : ('a, 'e) M.t -> f:('-> ('b, 'e) M.t) -> ('b, 'e) M.t
        val return : '-> ('a, 'b) M.t
        val map : ('a, 'e) M.t -> f:('-> 'b) -> ('b, 'e) M.t
        val join : (('a, 'e) M.t, 'e) M.t -> ('a, 'e) M.t
        val ignore_m : ('a, 'e) M.t -> (unit, 'e) M.t
        val all : ('a, 'e) M.t list -> ('a list, 'e) M.t
        val all_ignore : (unit, 'e) M.t list -> (unit, 'e) M.t
        module Syntax :
          sig
            val ( >>= ) :
              ('a, 'e) M.t -> ('-> ('b, 'e) M.t) -> ('b, 'e) M.t
            val ( >>| ) : ('a, 'e) M.t -> ('-> 'b) -> ('b, 'e) M.t
            val ( >=> ) :
              ('-> ('b, 'e) M.t) ->
              ('-> ('c, 'e) M.t) -> '-> ('c, 'e) M.t
            val ( !! ) : '-> ('a, 'e) M.t
            val ( !$ ) : ('-> 'b) -> ('a, 'e) M.t -> ('b, 'e) M.t
            val ( !$$ ) :
              ('-> '-> 'c) ->
              ('a, 'e) M.t -> ('b, 'e) M.t -> ('c, 'e) M.t
            val ( !$$$ ) :
              ('-> '-> '-> 'd) ->
              ('a, 'e) M.t -> ('b, 'e) M.t -> ('c, 'e) M.t -> ('d, 'e) M.t
            val ( !$$$$ ) :
              ('-> '-> '-> '-> 'e) ->
              ('a, 's) M.t ->
              ('b, 's) M.t -> ('c, 's) M.t -> ('d, 's) M.t -> ('e, 's) M.t
            val ( !$$$$$ ) :
              ('-> '-> '-> '-> '-> 'f) ->
              ('a, 's) M.t ->
              ('b, 's) M.t ->
              ('c, 's) M.t -> ('d, 's) M.t -> ('e, 's) M.t -> ('f, 's) M.t
          end
      end
  module Core :
    functor (M : Core->
      sig
        type 'a t = 'M.t
        val void : 'a t -> unit t
        val sequence : unit t list -> unit t
        val forever : 'a t -> 'b t
        module Fn :
          sig
            val id : '-> 'a t
            val ignore : 'a t -> unit t
            val nothing : unit -> unit t
            val non : ('-> bool t) -> '-> bool t
            val apply_n_times : n:int -> ('-> 'a t) -> '-> 'a t
            val compose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
          end
        module Pair :
          sig val fst : ('a * 'b) t -> 'a t val snd : ('a * 'b) t -> 'b t end
        module Triple :
          sig
            val fst : ('a * 'b * 'c) t -> 'a t
            val snd : ('a * 'b * 'c) t -> 'b t
            val trd : ('a * 'b * 'c) t -> 'c t
          end
        module Lift :
          sig
            val nullary : '-> 'a t
            val unary : ('-> 'b) -> 'a t -> 'b t
            val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
            val ternary :
              ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
            val quaternary :
              ('-> '-> '-> '-> 'e) ->
              'a t -> 'b t -> 'c t -> 'd t -> 'e t
            val quinary :
              ('-> '-> '-> '-> '-> 'f) ->
              'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
          end
        module Exn :
          sig
            val expect :
              ?finally:(unit -> unit t) ->
              f:(unit -> 'a t) -> catch:(exn -> 'a t) -> 'a t
          end
        module Collection :
          sig
            module type S =
              sig
                type 'a t
                val all : 'M.t t -> 'a t M.t
                val all_ignore : 'M.t t -> unit M.t
                val sequence : unit M.t t -> unit M.t
                val map : 'a t -> f:('-> 'M.t) -> 'b t M.t
                val iter : 'a t -> f:('-> unit M.t) -> unit M.t
                val fold :
                  'a t -> init:'-> f:('-> '-> 'M.t) -> 'M.t
                val fold_left :
                  'a t -> init:'-> f:('-> '-> 'M.t) -> 'M.t
                val fold_right :
                  'a t -> f:('-> '-> 'M.t) -> init:'-> 'M.t
                val reduce : 'a t -> f:('-> '-> 'M.t) -> 'a option M.t
                val exists : 'a t -> f:('-> bool M.t) -> bool M.t
                val for_all : 'a t -> f:('-> bool M.t) -> bool M.t
                val count : 'a t -> f:('-> bool M.t) -> int M.t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'b t -> f:('-> 'M.t) -> 'M.t
                val find : 'a t -> f:('-> bool M.t) -> 'a option M.t
                val find_map :
                  'a t -> f:('-> 'b option M.t) -> 'b option M.t
                val filter : 'a t -> f:('-> bool M.t) -> 'a t M.t
                val filter_map : 'a t -> f:('-> 'b option M.t) -> 'b t M.t
              end
            module Eager :
              functor (T : Collection.Eager->
                sig
                  val all : 'a t T.t -> 'T.t t
                  val all_ignore : 'a t T.t -> unit t
                  val sequence : unit t T.t -> unit t
                  val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                  val iter : 'T.t -> f:('-> unit t) -> unit t
                  val fold :
                    'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce : 'T.t -> f:('-> '-> 'a t) -> 'a option t
                  val exists : 'T.t -> f:('-> bool t) -> bool t
                  val for_all : 'T.t -> f:('-> bool t) -> bool t
                  val count : 'T.t -> f:('-> bool t) -> int t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'T.t -> f:('-> 'a t) -> 'a t
                  val find : 'T.t -> f:('-> bool t) -> 'a option t
                  val find_map :
                    'T.t -> f:('-> 'b option t) -> 'b option t
                  val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                  val filter_map :
                    'T.t -> f:('-> 'b option t) -> 'T.t t
                end
            module Delay :
              functor (T : Collection.Delay->
                sig
                  val all : 'a t T.t -> 'T.t t
                  val all_ignore : 'a t T.t -> unit t
                  val sequence : unit t T.t -> unit t
                  val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                  val iter : 'T.t -> f:('-> unit t) -> unit t
                  val fold :
                    'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce : 'T.t -> f:('-> '-> 'a t) -> 'a option t
                  val exists : 'T.t -> f:('-> bool t) -> bool t
                  val for_all : 'T.t -> f:('-> bool t) -> bool t
                  val count : 'T.t -> f:('-> bool t) -> int t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'T.t -> f:('-> 'a t) -> 'a t
                  val find : 'T.t -> f:('-> bool t) -> 'a option t
                  val find_map :
                    'T.t -> f:('-> 'b option t) -> 'b option t
                  val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                  val filter_map :
                    'T.t -> f:('-> 'b option t) -> 'T.t t
                end
          end
        module List :
          sig
            val all : 'a t list -> 'a list t
            val all_ignore : 'a t list -> unit t
            val sequence : unit t list -> unit t
            val map : 'a list -> f:('-> 'b t) -> 'b list t
            val iter : 'a list -> f:('-> unit t) -> unit t
            val fold : 'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
            val fold_left :
              'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
            val fold_right :
              'a list -> f:('-> '-> 'b t) -> init:'-> 'b t
            val reduce : 'a list -> f:('-> '-> 'a t) -> 'a option t
            val exists : 'a list -> f:('-> bool t) -> bool t
            val for_all : 'a list -> f:('-> bool t) -> bool t
            val count : 'a list -> f:('-> bool t) -> int t
            val map_reduce :
              (module Monoid.S with type t = 'a) ->
              'b list -> f:('-> 'a t) -> 'a t
            val find : 'a list -> f:('-> bool t) -> 'a option t
            val find_map : 'a list -> f:('-> 'b option t) -> 'b option t
            val filter : 'a list -> f:('-> bool t) -> 'a list t
            val filter_map : 'a list -> f:('-> 'b option t) -> 'b list t
          end
        module Seq :
          sig
            val all :
              'a t Core_kernel.Std.Sequence.t ->
              'Core_kernel.Std.Sequence.t t
            val all_ignore : 'a t Core_kernel.Std.Sequence.t -> unit t
            val sequence : unit t Core_kernel.Std.Sequence.t -> unit t
            val map :
              'Core_kernel.Std.Sequence.t ->
              f:('-> 'b t) -> 'Core_kernel.Std.Sequence.t t
            val iter :
              'Core_kernel.Std.Sequence.t -> f:('-> unit t) -> unit t
            val fold :
              'Core_kernel.Std.Sequence.t ->
              init:'-> f:('-> '-> 'b t) -> 'b t
            val fold_left :
              'Core_kernel.Std.Sequence.t ->
              init:'-> f:('-> '-> 'b t) -> 'b t
            val fold_right :
              'Core_kernel.Std.Sequence.t ->
              f:('-> '-> 'b t) -> init:'-> 'b t
            val reduce :
              'Core_kernel.Std.Sequence.t ->
              f:('-> '-> 'a t) -> 'a option t
            val exists :
              'Core_kernel.Std.Sequence.t -> f:('-> bool t) -> bool t
            val for_all :
              'Core_kernel.Std.Sequence.t -> f:('-> bool t) -> bool t
            val count :
              'Core_kernel.Std.Sequence.t -> f:('-> bool t) -> int t
            val map_reduce :
              (module Monoid.S with type t = 'a) ->
              'Core_kernel.Std.Sequence.t -> f:('-> 'a t) -> 'a t
            val find :
              'Core_kernel.Std.Sequence.t ->
              f:('-> bool t) -> 'a option t
            val find_map :
              'Core_kernel.Std.Sequence.t ->
              f:('-> 'b option t) -> 'b option t
            val filter :
              'Core_kernel.Std.Sequence.t ->
              f:('-> bool t) -> 'Core_kernel.Std.Sequence.t t
            val filter_map :
              'Core_kernel.Std.Sequence.t ->
              f:('-> 'b option t) -> 'Core_kernel.Std.Sequence.t t
          end
        val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
        val ( !! ) : '-> 'a t
        val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
        val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
        val ( !$$$ ) : ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
        val ( !$$$$ ) :
          ('-> '-> '-> '-> 'e) ->
          'a t -> 'b t -> 'c t -> 'd t -> 'e t
        val ( !$$$$$ ) :
          ('-> '-> '-> '-> '-> 'f) ->
          'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
        val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
        val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
        module Monad_infix :
          sig
            val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
            val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
          end
        val bind : 'a t -> f:('-> 'b t) -> 'b t
        val return : '-> 'a t
        val map : 'a t -> f:('-> 'b) -> 'b t
        val join : 'a t t -> 'a t
        val ignore_m : 'a t -> unit t
        val all : 'a t list -> 'a list t
        val all_ignore : unit t list -> unit t
        module Let_syntax :
          sig
            val return : '-> 'a t
            val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
            val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
            module Let_syntax :
              sig
                val return : '-> 'a t
                val bind : 'a t -> f:('-> 'b t) -> 'b t
                val map : 'a t -> f:('-> 'b) -> 'b t
                val both : 'a t -> 'b t -> ('a * 'b) t
                module Open_on_rhs : sig  end
              end
          end
        module Syntax :
          sig
            val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
            val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
            val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
            val ( !! ) : '-> 'a t
            val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
            val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
            val ( !$$$ ) :
              ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
            val ( !$$$$ ) :
              ('-> '-> '-> '-> 'e) ->
              'a t -> 'b t -> 'c t -> 'd t -> 'e t
            val ( !$$$$$ ) :
              ('-> '-> '-> '-> '-> 'f) ->
              'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
          end
      end
  module Core2 :
    functor (M : Core2->
      sig
        type ('a, 'e) t = ('a, 'e) M.t
        val void : ('a, 'e) t -> (unit, 'e) t
        val sequence : (unit, 'e) t list -> (unit, 'e) t
        val forever : ('a, 'e) t -> ('b, 'e) t
        module Fn :
          sig
            val id : '-> ('a, 'e) t
            val ignore : ('a, 'e) t -> (unit, 'e) t
            val nothing : unit -> (unit, 'e) t
            val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
            val apply_n_times :
              n:int -> ('-> ('a, 'e) t) -> '-> ('a, 'e) t
            val compose :
              ('-> ('c, 'e) t) -> ('-> ('b, 'e) t) -> '-> ('c, 'e) t
          end
        module Pair :
          sig
            val fst : ('a * 'b, 'e) t -> ('a, 'e) t
            val snd : ('a * 'b, 'e) t -> ('b, 'e) t
          end
        module Triple :
          sig
            val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
            val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
            val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
          end
        module Lift :
          sig
            val nullary : '-> ('a, 'e) t
            val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
            val binary :
              ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
            val ternary :
              ('-> '-> '-> 'd) ->
              ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
            val quaternary :
              ('-> '-> '-> '-> 'e) ->
              ('a, 's) t ->
              ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
            val quinary :
              ('-> '-> '-> '-> '-> 'f) ->
              ('a, 's) t ->
              ('b, 's) t ->
              ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
          end
        module Exn :
          sig
            val expect :
              ?finally:(unit -> (unit, 's) t) ->
              f:(unit -> ('a, 's) t) ->
              catch:(exn -> ('a, 's) t) -> ('a, 's) t
          end
        module Collection :
          sig
            module type S =
              sig
                type 'a t
                val all : ('a, 'e) M.t t -> ('a t, 'e) M.t
                val all_ignore : ('a, 'e) M.t t -> (unit, 'e) M.t
                val sequence : (unit, 'e) M.t t -> (unit, 'e) M.t
                val map : 'a t -> f:('-> ('b, 'e) M.t) -> ('b t, 'e) M.t
                val iter : 'a t -> f:('-> (unit, 'e) M.t) -> (unit, 'e) M.t
                val fold :
                  'a t ->
                  init:'-> f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
                val fold_left :
                  'a t ->
                  init:'-> f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
                val fold_right :
                  'a t ->
                  f:('-> '-> ('b, 'e) M.t) -> init:'-> ('b, 'e) M.t
                val reduce :
                  'a t -> f:('-> '-> ('a, 'e) M.t) -> ('a option, 'e) M.t
                val exists :
                  'a t -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
                val for_all :
                  'a t -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
                val count : 'a t -> f:('-> (bool, 'e) M.t) -> (int, 'e) M.t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'b t -> f:('-> ('a, 'e) M.t) -> ('a, 'e) M.t
                val find :
                  'a t -> f:('-> (bool, 'e) M.t) -> ('a option, 'e) M.t
                val find_map :
                  'a t ->
                  f:('-> ('b option, 'e) M.t) -> ('b option, 'e) M.t
                val filter :
                  'a t -> f:('-> (bool, 'e) M.t) -> ('a t, 'e) M.t
                val filter_map :
                  'a t -> f:('-> ('b option, 'e) M.t) -> ('b t, 'e) M.t
              end
            module Eager :
              functor (T : Collection.Eager->
                sig
                  val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                  val all_ignore : ('a, 'e) t T.t -> (unit, 'e) t
                  val sequence : (unit, 'e) t T.t -> (unit, 'e) t
                  val map : 'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                  val iter : 'T.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                  val fold :
                    'T.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'T.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'T.t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'T.t -> f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                  val exists :
                    'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count : 'T.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'T.t -> f:('-> (bool, 'e) t) -> ('a option, 'e) t
                  val find_map :
                    'T.t ->
                    f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                  val filter :
                    'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                  val filter_map :
                    'T.t -> f:('-> ('b option, 'e) t) -> ('T.t, 'e) t
                end
            module Delay :
              functor (T : Collection.Delay->
                sig
                  val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                  val all_ignore : ('a, 'e) t T.t -> (unit, 'e) t
                  val sequence : (unit, 'e) t T.t -> (unit, 'e) t
                  val map : 'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                  val iter : 'T.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                  val fold :
                    'T.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'T.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'T.t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'T.t -> f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                  val exists :
                    'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count : 'T.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'T.t -> f:('-> (bool, 'e) t) -> ('a option, 'e) t
                  val find_map :
                    'T.t ->
                    f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                  val filter :
                    'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                  val filter_map :
                    'T.t -> f:('-> ('b option, 'e) t) -> ('T.t, 'e) t
                end
          end
        module List :
          sig
            val all : ('a, 'e) t list -> ('a list, 'e) t
            val all_ignore : ('a, 'e) t list -> (unit, 'e) t
            val sequence : (unit, 'e) t list -> (unit, 'e) t
            val map : 'a list -> f:('-> ('b, 'e) t) -> ('b list, 'e) t
            val iter : 'a list -> f:('-> (unit, 'e) t) -> (unit, 'e) t
            val fold :
              'a list -> init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
            val fold_left :
              'a list -> init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
            val fold_right :
              'a list -> f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
            val reduce :
              'a list -> f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
            val exists : 'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t
            val for_all : 'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t
            val count : 'a list -> f:('-> (bool, 'e) t) -> (int, 'e) t
            val map_reduce :
              (module Monoid.S with type t = 'a) ->
              'b list -> f:('-> ('a, 'e) t) -> ('a, 'e) t
            val find : 'a list -> f:('-> (bool, 'e) t) -> ('a option, 'e) t
            val find_map :
              'a list -> f:('-> ('b option, 'e) t) -> ('b option, 'e) t
            val filter : 'a list -> f:('-> (bool, 'e) t) -> ('a list, 'e) t
            val filter_map :
              'a list -> f:('-> ('b option, 'e) t) -> ('b list, 'e) t
          end
        module Seq :
          sig
            val all :
              ('a, 'e) t Core_kernel.Std.Sequence.t ->
              ('Core_kernel.Std.Sequence.t, 'e) t
            val all_ignore :
              ('a, 'e) t Core_kernel.Std.Sequence.t -> (unit, 'e) t
            val sequence :
              (unit, 'e) t Core_kernel.Std.Sequence.t -> (unit, 'e) t
            val map :
              'Core_kernel.Std.Sequence.t ->
              f:('-> ('b, 'e) t) -> ('Core_kernel.Std.Sequence.t, 'e) t
            val iter :
              'Core_kernel.Std.Sequence.t ->
              f:('-> (unit, 'e) t) -> (unit, 'e) t
            val fold :
              'Core_kernel.Std.Sequence.t ->
              init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
            val fold_left :
              'Core_kernel.Std.Sequence.t ->
              init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
            val fold_right :
              'Core_kernel.Std.Sequence.t ->
              f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
            val reduce :
              'Core_kernel.Std.Sequence.t ->
              f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
            val exists :
              'Core_kernel.Std.Sequence.t ->
              f:('-> (bool, 'e) t) -> (bool, 'e) t
            val for_all :
              'Core_kernel.Std.Sequence.t ->
              f:('-> (bool, 'e) t) -> (bool, 'e) t
            val count :
              'Core_kernel.Std.Sequence.t ->
              f:('-> (bool, 'e) t) -> (int, 'e) t
            val map_reduce :
              (module Monoid.S with type t = 'a) ->
              'Core_kernel.Std.Sequence.t ->
              f:('-> ('a, 'e) t) -> ('a, 'e) t
            val find :
              'Core_kernel.Std.Sequence.t ->
              f:('-> (bool, 'e) t) -> ('a option, 'e) t
            val find_map :
              'Core_kernel.Std.Sequence.t ->
              f:('-> ('b option, 'e) t) -> ('b option, 'e) t
            val filter :
              'Core_kernel.Std.Sequence.t ->
              f:('-> (bool, 'e) t) -> ('Core_kernel.Std.Sequence.t, 'e) t
            val filter_map :
              'Core_kernel.Std.Sequence.t ->
              f:('-> ('b option, 'e) t) ->
              ('Core_kernel.Std.Sequence.t, 'e) t
          end
        val ( >=> ) :
          ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
        val ( !! ) : '-> ('a, 'e) t
        val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
        val ( !$$ ) :
          ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
        val ( !$$$ ) :
          ('-> '-> '-> 'd) ->
          ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
        val ( !$$$$ ) :
          ('-> '-> '-> '-> 'e) ->
          ('a, 's) t -> ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
        val ( !$$$$$ ) :
          ('-> '-> '-> '-> '-> 'f) ->
          ('a, 's) t ->
          ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
        val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
        val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
        module Let_syntax :
          sig
            val return : '-> ('a, 'b) t
            val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
            val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
            module Let_syntax :
              sig
                val return : '-> ('a, 'b) t
                val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                module Open_on_rhs : sig  end
              end
          end
        module Monad_infix :
          sig
            val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
            val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
          end
        val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
        val return : '-> ('a, 'b) t
        val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
        val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
        val ignore_m : ('a, 'e) t -> (unit, 'e) t
        val all : ('a, 'e) t list -> ('a list, 'e) t
        val all_ignore : (unit, 'e) t list -> (unit, 'e) t
        module Syntax :
          sig
            val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
            val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
            val ( >=> ) :
              ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
            val ( !! ) : '-> ('a, 'e) t
            val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
            val ( !$$ ) :
              ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
            val ( !$$$ ) :
              ('-> '-> '-> 'd) ->
              ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
            val ( !$$$$ ) :
              ('-> '-> '-> '-> 'e) ->
              ('a, 's) t ->
              ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
            val ( !$$$$$ ) :
              ('-> '-> '-> '-> '-> 'f) ->
              ('a, 's) t ->
              ('b, 's) t ->
              ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
          end
      end
  module Minimal :
    functor (M : Minimal->
      sig
        type 'a t = 'M.t
        val void : 'a t -> unit t
        val sequence : unit t list -> unit t
        val forever : 'a t -> 'b t
        module Fn :
          sig
            val id : '-> 'a t
            val ignore : 'a t -> unit t
            val nothing : unit -> unit t
            val non : ('-> bool t) -> '-> bool t
            val apply_n_times : n:int -> ('-> 'a t) -> '-> 'a t
            val compose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
          end
        module Pair :
          sig val fst : ('a * 'b) t -> 'a t val snd : ('a * 'b) t -> 'b t end
        module Triple :
          sig
            val fst : ('a * 'b * 'c) t -> 'a t
            val snd : ('a * 'b * 'c) t -> 'b t
            val trd : ('a * 'b * 'c) t -> 'c t
          end
        module Lift :
          sig
            val nullary : '-> 'a t
            val unary : ('-> 'b) -> 'a t -> 'b t
            val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
            val ternary :
              ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
            val quaternary :
              ('-> '-> '-> '-> 'e) ->
              'a t -> 'b t -> 'c t -> 'd t -> 'e t
            val quinary :
              ('-> '-> '-> '-> '-> 'f) ->
              'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
          end
        module Exn :
          sig
            val expect :
              ?finally:(unit -> unit t) ->
              f:(unit -> 'a t) -> catch:(exn -> 'a t) -> 'a t
          end
        module Collection :
          sig
            module type S =
              sig
                type 'a t
                val all : 'M.t t -> 'a t M.t
                val all_ignore : 'M.t t -> unit M.t
                val sequence : unit M.t t -> unit M.t
                val map : 'a t -> f:('-> 'M.t) -> 'b t M.t
                val iter : 'a t -> f:('-> unit M.t) -> unit M.t
                val fold :
                  'a t -> init:'-> f:('-> '-> 'M.t) -> 'M.t
                val fold_left :
                  'a t -> init:'-> f:('-> '-> 'M.t) -> 'M.t
                val fold_right :
                  'a t -> f:('-> '-> 'M.t) -> init:'-> 'M.t
                val reduce : 'a t -> f:('-> '-> 'M.t) -> 'a option M.t
                val exists : 'a t -> f:('-> bool M.t) -> bool M.t
                val for_all : 'a t -> f:('-> bool M.t) -> bool M.t
                val count : 'a t -> f:('-> bool M.t) -> int M.t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'b t -> f:('-> 'M.t) -> 'M.t
                val find : 'a t -> f:('-> bool M.t) -> 'a option M.t
                val find_map :
                  'a t -> f:('-> 'b option M.t) -> 'b option M.t
                val filter : 'a t -> f:('-> bool M.t) -> 'a t M.t
                val filter_map : 'a t -> f:('-> 'b option M.t) -> 'b t M.t
              end
            module Eager :
              functor (T : Collection.Eager->
                sig
                  val all : 'a t T.t -> 'T.t t
                  val all_ignore : 'a t T.t -> unit t
                  val sequence : unit t T.t -> unit t
                  val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                  val iter : 'T.t -> f:('-> unit t) -> unit t
                  val fold :
                    'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce : 'T.t -> f:('-> '-> 'a t) -> 'a option t
                  val exists : 'T.t -> f:('-> bool t) -> bool t
                  val for_all : 'T.t -> f:('-> bool t) -> bool t
                  val count : 'T.t -> f:('-> bool t) -> int t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'T.t -> f:('-> 'a t) -> 'a t
                  val find : 'T.t -> f:('-> bool t) -> 'a option t
                  val find_map :
                    'T.t -> f:('-> 'b option t) -> 'b option t
                  val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                  val filter_map :
                    'T.t -> f:('-> 'b option t) -> 'T.t t
                end
            module Delay :
              functor (T : Collection.Delay->
                sig
                  val all : 'a t T.t -> 'T.t t
                  val all_ignore : 'a t T.t -> unit t
                  val sequence : unit t T.t -> unit t
                  val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                  val iter : 'T.t -> f:('-> unit t) -> unit t
                  val fold :
                    'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce : 'T.t -> f:('-> '-> 'a t) -> 'a option t
                  val exists : 'T.t -> f:('-> bool t) -> bool t
                  val for_all : 'T.t -> f:('-> bool t) -> bool t
                  val count : 'T.t -> f:('-> bool t) -> int t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'T.t -> f:('-> 'a t) -> 'a t
                  val find : 'T.t -> f:('-> bool t) -> 'a option t
                  val find_map :
                    'T.t -> f:('-> 'b option t) -> 'b option t
                  val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                  val filter_map :
                    'T.t -> f:('-> 'b option t) -> 'T.t t
                end
          end
        module List :
          sig
            val all : 'a t list -> 'a list t
            val all_ignore : 'a t list -> unit t
            val sequence : unit t list -> unit t
            val map : 'a list -> f:('-> 'b t) -> 'b list t
            val iter : 'a list -> f:('-> unit t) -> unit t
            val fold : 'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
            val fold_left :
              'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
            val fold_right :
              'a list -> f:('-> '-> 'b t) -> init:'-> 'b t
            val reduce : 'a list -> f:('-> '-> 'a t) -> 'a option t
            val exists : 'a list -> f:('-> bool t) -> bool t
            val for_all : 'a list -> f:('-> bool t) -> bool t
            val count : 'a list -> f:('-> bool t) -> int t
            val map_reduce :
              (module Monoid.S with type t = 'a) ->
              'b list -> f:('-> 'a t) -> 'a t
            val find : 'a list -> f:('-> bool t) -> 'a option t
            val find_map : 'a list -> f:('-> 'b option t) -> 'b option t
            val filter : 'a list -> f:('-> bool t) -> 'a list t
            val filter_map : 'a list -> f:('-> 'b option t) -> 'b list t
          end
        module Seq :
          sig
            val all :
              'a t Core_kernel.Std.Sequence.t ->
              'Core_kernel.Std.Sequence.t t
            val all_ignore : 'a t Core_kernel.Std.Sequence.t -> unit t
            val sequence : unit t Core_kernel.Std.Sequence.t -> unit t
            val map :
              'Core_kernel.Std.Sequence.t ->
              f:('-> 'b t) -> 'Core_kernel.Std.Sequence.t t
            val iter :
              'Core_kernel.Std.Sequence.t -> f:('-> unit t) -> unit t
            val fold :
              'Core_kernel.Std.Sequence.t ->
              init:'-> f:('-> '-> 'b t) -> 'b t
            val fold_left :
              'Core_kernel.Std.Sequence.t ->
              init:'-> f:('-> '-> 'b t) -> 'b t
            val fold_right :
              'Core_kernel.Std.Sequence.t ->
              f:('-> '-> 'b t) -> init:'-> 'b t
            val reduce :
              'Core_kernel.Std.Sequence.t ->
              f:('-> '-> 'a t) -> 'a option t
            val exists :
              'Core_kernel.Std.Sequence.t -> f:('-> bool t) -> bool t
            val for_all :
              'Core_kernel.Std.Sequence.t -> f:('-> bool t) -> bool t
            val count :
              'Core_kernel.Std.Sequence.t -> f:('-> bool t) -> int t
            val map_reduce :
              (module Monoid.S with type t = 'a) ->
              'Core_kernel.Std.Sequence.t -> f:('-> 'a t) -> 'a t
            val find :
              'Core_kernel.Std.Sequence.t ->
              f:('-> bool t) -> 'a option t
            val find_map :
              'Core_kernel.Std.Sequence.t ->
              f:('-> 'b option t) -> 'b option t
            val filter :
              'Core_kernel.Std.Sequence.t ->
              f:('-> bool t) -> 'Core_kernel.Std.Sequence.t t
            val filter_map :
              'Core_kernel.Std.Sequence.t ->
              f:('-> 'b option t) -> 'Core_kernel.Std.Sequence.t t
          end
        val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
        val ( !! ) : '-> 'a t
        val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
        val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
        val ( !$$$ ) : ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
        val ( !$$$$ ) :
          ('-> '-> '-> '-> 'e) ->
          'a t -> 'b t -> 'c t -> 'd t -> 'e t
        val ( !$$$$$ ) :
          ('-> '-> '-> '-> '-> 'f) ->
          'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
        val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
        val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
        module Monad_infix :
          sig
            val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
            val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
          end
        val bind : 'a t -> f:('-> 'b t) -> 'b t
        val return : '-> 'a t
        val map : 'a t -> f:('-> 'b) -> 'b t
        val join : 'a t t -> 'a t
        val ignore_m : 'a t -> unit t
        val all : 'a t list -> 'a list t
        val all_ignore : unit t list -> unit t
        module Let_syntax :
          sig
            val return : '-> 'a t
            val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
            val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
            module Let_syntax :
              sig
                val return : '-> 'a t
                val bind : 'a t -> f:('-> 'b t) -> 'b t
                val map : 'a t -> f:('-> 'b) -> 'b t
                val both : 'a t -> 'b t -> ('a * 'b) t
                module Open_on_rhs : sig  end
              end
          end
        module Syntax :
          sig
            val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
            val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
            val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
            val ( !! ) : '-> 'a t
            val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
            val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
            val ( !$$$ ) :
              ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
            val ( !$$$$ ) :
              ('-> '-> '-> '-> 'e) ->
              'a t -> 'b t -> 'c t -> 'd t -> 'e t
            val ( !$$$$$ ) :
              ('-> '-> '-> '-> '-> 'f) ->
              'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
          end
      end
  module Minimal2 :
    functor (M : Minimal2->
      sig
        type ('a, 'e) t = ('a, 'e) M.t
        val void : ('a, 'e) t -> (unit, 'e) t
        val sequence : (unit, 'e) t list -> (unit, 'e) t
        val forever : ('a, 'e) t -> ('b, 'e) t
        module Fn :
          sig
            val id : '-> ('a, 'e) t
            val ignore : ('a, 'e) t -> (unit, 'e) t
            val nothing : unit -> (unit, 'e) t
            val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
            val apply_n_times :
              n:int -> ('-> ('a, 'e) t) -> '-> ('a, 'e) t
            val compose :
              ('-> ('c, 'e) t) -> ('-> ('b, 'e) t) -> '-> ('c, 'e) t
          end
        module Pair :
          sig
            val fst : ('a * 'b, 'e) t -> ('a, 'e) t
            val snd : ('a * 'b, 'e) t -> ('b, 'e) t
          end
        module Triple :
          sig
            val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
            val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
            val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
          end
        module Lift :
          sig
            val nullary : '-> ('a, 'e) t
            val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
            val binary :
              ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
            val ternary :
              ('-> '-> '-> 'd) ->
              ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
            val quaternary :
              ('-> '-> '-> '-> 'e) ->
              ('a, 's) t ->
              ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
            val quinary :
              ('-> '-> '-> '-> '-> 'f) ->
              ('a, 's) t ->
              ('b, 's) t ->
              ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
          end
        module Exn :
          sig
            val expect :
              ?finally:(unit -> (unit, 's) t) ->
              f:(unit -> ('a, 's) t) ->
              catch:(exn -> ('a, 's) t) -> ('a, 's) t
          end
        module Collection :
          sig
            module type S =
              sig
                type 'a t
                val all : ('a, 'e) M.t t -> ('a t, 'e) M.t
                val all_ignore : ('a, 'e) M.t t -> (unit, 'e) M.t
                val sequence : (unit, 'e) M.t t -> (unit, 'e) M.t
                val map : 'a t -> f:('-> ('b, 'e) M.t) -> ('b t, 'e) M.t
                val iter : 'a t -> f:('-> (unit, 'e) M.t) -> (unit, 'e) M.t
                val fold :
                  'a t ->
                  init:'-> f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
                val fold_left :
                  'a t ->
                  init:'-> f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
                val fold_right :
                  'a t ->
                  f:('-> '-> ('b, 'e) M.t) -> init:'-> ('b, 'e) M.t
                val reduce :
                  'a t -> f:('-> '-> ('a, 'e) M.t) -> ('a option, 'e) M.t
                val exists :
                  'a t -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
                val for_all :
                  'a t -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
                val count : 'a t -> f:('-> (bool, 'e) M.t) -> (int, 'e) M.t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'b t -> f:('-> ('a, 'e) M.t) -> ('a, 'e) M.t
                val find :
                  'a t -> f:('-> (bool, 'e) M.t) -> ('a option, 'e) M.t
                val find_map :
                  'a t ->
                  f:('-> ('b option, 'e) M.t) -> ('b option, 'e) M.t
                val filter :
                  'a t -> f:('-> (bool, 'e) M.t) -> ('a t, 'e) M.t
                val filter_map :
                  'a t -> f:('-> ('b option, 'e) M.t) -> ('b t, 'e) M.t
              end
            module Eager :
              functor (T : Collection.Eager->
                sig
                  val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                  val all_ignore : ('a, 'e) t T.t -> (unit, 'e) t
                  val sequence : (unit, 'e) t T.t -> (unit, 'e) t
                  val map : 'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                  val iter : 'T.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                  val fold :
                    'T.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'T.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'T.t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'T.t -> f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                  val exists :
                    'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count : 'T.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'T.t -> f:('-> (bool, 'e) t) -> ('a option, 'e) t
                  val find_map :
                    'T.t ->
                    f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                  val filter :
                    'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                  val filter_map :
                    'T.t -> f:('-> ('b option, 'e) t) -> ('T.t, 'e) t
                end
            module Delay :
              functor (T : Collection.Delay->
                sig
                  val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                  val all_ignore : ('a, 'e) t T.t -> (unit, 'e) t
                  val sequence : (unit, 'e) t T.t -> (unit, 'e) t
                  val map : 'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                  val iter : 'T.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                  val fold :
                    'T.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'T.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'T.t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'T.t -> f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                  val exists :
                    'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count : 'T.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'T.t -> f:('-> (bool, 'e) t) -> ('a option, 'e) t
                  val find_map :
                    'T.t ->
                    f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                  val filter :
                    'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                  val filter_map :
                    'T.t -> f:('-> ('b option, 'e) t) -> ('T.t, 'e) t
                end
          end
        module List :
          sig
            val all : ('a, 'e) t list -> ('a list, 'e) t
            val all_ignore : ('a, 'e) t list -> (unit, 'e) t
            val sequence : (unit, 'e) t list -> (unit, 'e) t
            val map : 'a list -> f:('-> ('b, 'e) t) -> ('b list, 'e) t
            val iter : 'a list -> f:('-> (unit, 'e) t) -> (unit, 'e) t
            val fold :
              'a list -> init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
            val fold_left :
              'a list -> init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
            val fold_right :
              'a list -> f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
            val reduce :
              'a list -> f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
            val exists : 'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t
            val for_all : 'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t
            val count : 'a list -> f:('-> (bool, 'e) t) -> (int, 'e) t
            val map_reduce :
              (module Monoid.S with type t = 'a) ->
              'b list -> f:('-> ('a, 'e) t) -> ('a, 'e) t
            val find : 'a list -> f:('-> (bool, 'e) t) -> ('a option, 'e) t
            val find_map :
              'a list -> f:('-> ('b option, 'e) t) -> ('b option, 'e) t
            val filter : 'a list -> f:('-> (bool, 'e) t) -> ('a list, 'e) t
            val filter_map :
              'a list -> f:('-> ('b option, 'e) t) -> ('b list, 'e) t
          end
        module Seq :
          sig
            val all :
              ('a, 'e) t Core_kernel.Std.Sequence.t ->
              ('Core_kernel.Std.Sequence.t, 'e) t
            val all_ignore :
              ('a, 'e) t Core_kernel.Std.Sequence.t -> (unit, 'e) t
            val sequence :
              (unit, 'e) t Core_kernel.Std.Sequence.t -> (unit, 'e) t
            val map :
              'Core_kernel.Std.Sequence.t ->
              f:('-> ('b, 'e) t) -> ('Core_kernel.Std.Sequence.t, 'e) t
            val iter :
              'Core_kernel.Std.Sequence.t ->
              f:('-> (unit, 'e) t) -> (unit, 'e) t
            val fold :
              'Core_kernel.Std.Sequence.t ->
              init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
            val fold_left :
              'Core_kernel.Std.Sequence.t ->
              init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
            val fold_right :
              'Core_kernel.Std.Sequence.t ->
              f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
            val reduce :
              'Core_kernel.Std.Sequence.t ->
              f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
            val exists :
              'Core_kernel.Std.Sequence.t ->
              f:('-> (bool, 'e) t) -> (bool, 'e) t
            val for_all :
              'Core_kernel.Std.Sequence.t ->
              f:('-> (bool, 'e) t) -> (bool, 'e) t
            val count :
              'Core_kernel.Std.Sequence.t ->
              f:('-> (bool, 'e) t) -> (int, 'e) t
            val map_reduce :
              (module Monoid.S with type t = 'a) ->
              'Core_kernel.Std.Sequence.t ->
              f:('-> ('a, 'e) t) -> ('a, 'e) t
            val find :
              'Core_kernel.Std.Sequence.t ->
              f:('-> (bool, 'e) t) -> ('a option, 'e) t
            val find_map :
              'Core_kernel.Std.Sequence.t ->
              f:('-> ('b option, 'e) t) -> ('b option, 'e) t
            val filter :
              'Core_kernel.Std.Sequence.t ->
              f:('-> (bool, 'e) t) -> ('Core_kernel.Std.Sequence.t, 'e) t
            val filter_map :
              'Core_kernel.Std.Sequence.t ->
              f:('-> ('b option, 'e) t) ->
              ('Core_kernel.Std.Sequence.t, 'e) t
          end
        val ( >=> ) :
          ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
        val ( !! ) : '-> ('a, 'e) t
        val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
        val ( !$$ ) :
          ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
        val ( !$$$ ) :
          ('-> '-> '-> 'd) ->
          ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
        val ( !$$$$ ) :
          ('-> '-> '-> '-> 'e) ->
          ('a, 's) t -> ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
        val ( !$$$$$ ) :
          ('-> '-> '-> '-> '-> 'f) ->
          ('a, 's) t ->
          ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
        val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
        val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
        module Let_syntax :
          sig
            val return : '-> ('a, 'b) t
            val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
            val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
            module Let_syntax :
              sig
                val return : '-> ('a, 'b) t
                val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                module Open_on_rhs : sig  end
              end
          end
        module Monad_infix :
          sig
            val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
            val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
          end
        val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
        val return : '-> ('a, 'b) t
        val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
        val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
        val ignore_m : ('a, 'e) t -> (unit, 'e) t
        val all : ('a, 'e) t list -> ('a list, 'e) t
        val all_ignore : (unit, 'e) t list -> (unit, 'e) t
        module Syntax :
          sig
            val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
            val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
            val ( >=> ) :
              ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
            val ( !! ) : '-> ('a, 'e) t
            val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
            val ( !$$ ) :
              ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
            val ( !$$$ ) :
              ('-> '-> '-> 'd) ->
              ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
            val ( !$$$$ ) :
              ('-> '-> '-> '-> 'e) ->
              ('a, 's) t ->
              ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
            val ( !$$$$$ ) :
              ('-> '-> '-> '-> '-> 'f) ->
              ('a, 's) t ->
              ('b, 's) t ->
              ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
          end
      end
  module type Monad = S
  module type Monad2 = S2
  module Ident :
    sig
      type 'a t = 'a
      val void : '-> unit
      val sequence : unit list -> unit
      val forever : '-> 'b
      module Fn :
        sig
          val id : '-> 'a
          val ignore : '-> unit
          val nothing : unit -> unit
          val non : ('-> bool) -> '-> bool
          val apply_n_times : n:int -> ('-> 'a) -> '-> 'a
          val compose : ('-> 'c) -> ('-> 'b) -> '-> 'c
        end
      module Pair : sig val fst : 'a * '-> 'val snd : 'a * '-> 'end
      module Triple :
        sig
          val fst : 'a * 'b * '-> 'a
          val snd : 'a * 'b * '-> 'b
          val trd : 'a * 'b * '-> 'c
        end
      module Lift :
        sig
          val nullary : '-> 'a
          val unary : ('-> 'b) -> '-> 'b
          val binary : ('-> '-> 'c) -> '-> '-> 'c
          val ternary : ('-> '-> '-> 'd) -> '-> '-> '-> 'd
          val quaternary :
            ('-> '-> '-> '-> 'e) -> '-> '-> '-> '-> 'e
          val quinary :
            ('-> '-> '-> '-> '-> 'f) ->
            '-> '-> '-> '-> '-> 'f
        end
      module Exn :
        sig
          val expect :
            ?finally:(unit -> unit) ->
            f:(unit -> 'a) -> catch:(exn -> 'a) -> 'a
        end
      module Collection :
        sig
          module type S =
            sig
              type 'a t
              val all : 'a t -> 'a t
              val all_ignore : 'a t -> unit
              val sequence : unit t -> unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val iter : 'a t -> f:('-> unit) -> unit
              val fold : 'a t -> init:'-> f:('-> '-> 'b) -> 'b
              val fold_left : 'a t -> init:'-> f:('-> '-> 'b) -> 'b
              val fold_right : 'a t -> f:('-> '-> 'b) -> init:'-> 'b
              val reduce : 'a t -> f:('-> '-> 'a) -> 'a option
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'b t -> f:('-> 'a) -> 'a
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
            end
          module Eager :
            functor (T : Collection.Eager->
              sig
                val all : 'T.t -> 'T.t
                val all_ignore : 'T.t -> unit
                val sequence : unit T.t -> unit
                val map : 'T.t -> f:('-> 'b) -> 'T.t
                val iter : 'T.t -> f:('-> unit) -> unit
                val fold : 'T.t -> init:'-> f:('-> '-> 'b) -> 'b
                val fold_left : 'T.t -> init:'-> f:('-> '-> 'b) -> 'b
                val fold_right :
                  'T.t -> f:('-> '-> 'b) -> init:'-> 'b
                val reduce : 'T.t -> f:('-> '-> 'a) -> 'a option
                val exists : 'T.t -> f:('-> bool) -> bool
                val for_all : 'T.t -> f:('-> bool) -> bool
                val count : 'T.t -> f:('-> bool) -> int
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'T.t -> f:('-> 'a) -> 'a
                val find : 'T.t -> f:('-> bool) -> 'a option
                val find_map : 'T.t -> f:('-> 'b option) -> 'b option
                val filter : 'T.t -> f:('-> bool) -> 'T.t
                val filter_map : 'T.t -> f:('-> 'b option) -> 'T.t
              end
          module Delay :
            functor (T : Collection.Delay->
              sig
                val all : 'T.t -> 'T.t
                val all_ignore : 'T.t -> unit
                val sequence : unit T.t -> unit
                val map : 'T.t -> f:('-> 'b) -> 'T.t
                val iter : 'T.t -> f:('-> unit) -> unit
                val fold : 'T.t -> init:'-> f:('-> '-> 'b) -> 'b
                val fold_left : 'T.t -> init:'-> f:('-> '-> 'b) -> 'b
                val fold_right :
                  'T.t -> f:('-> '-> 'b) -> init:'-> 'b
                val reduce : 'T.t -> f:('-> '-> 'a) -> 'a option
                val exists : 'T.t -> f:('-> bool) -> bool
                val for_all : 'T.t -> f:('-> bool) -> bool
                val count : 'T.t -> f:('-> bool) -> int
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'T.t -> f:('-> 'a) -> 'a
                val find : 'T.t -> f:('-> bool) -> 'a option
                val find_map : 'T.t -> f:('-> 'b option) -> 'b option
                val filter : 'T.t -> f:('-> bool) -> 'T.t
                val filter_map : 'T.t -> f:('-> 'b option) -> 'T.t
              end
        end
      module List :
        sig
          val all : 'a list -> 'a list
          val all_ignore : 'a list -> unit
          val sequence : unit list -> unit
          val map : 'a list -> f:('-> 'b) -> 'b list
          val iter : 'a list -> f:('-> unit) -> unit
          val fold : 'a list -> init:'-> f:('-> '-> 'b) -> 'b
          val fold_left : 'a list -> init:'-> f:('-> '-> 'b) -> 'b
          val fold_right : 'a list -> f:('-> '-> 'b) -> init:'-> 'b
          val reduce : 'a list -> f:('-> '-> 'a) -> 'a option
          val exists : 'a list -> f:('-> bool) -> bool
          val for_all : 'a list -> f:('-> bool) -> bool
          val count : 'a list -> f:('-> bool) -> int
          val map_reduce :
            (module Monoid.S with type t = 'a) ->
            'b list -> f:('-> 'a) -> 'a
          val find : 'a list -> f:('-> bool) -> 'a option
          val find_map : 'a list -> f:('-> 'b option) -> 'b option
          val filter : 'a list -> f:('-> bool) -> 'a list
          val filter_map : 'a list -> f:('-> 'b option) -> 'b list
        end
      module Seq :
        sig
          val all :
            'Core_kernel.Std.Sequence.t -> 'Core_kernel.Std.Sequence.t
          val all_ignore : 'Core_kernel.Std.Sequence.t -> unit
          val sequence : unit Core_kernel.Std.Sequence.t -> unit
          val map :
            'Core_kernel.Std.Sequence.t ->
            f:('-> 'b) -> 'Core_kernel.Std.Sequence.t
          val iter : 'Core_kernel.Std.Sequence.t -> f:('-> unit) -> unit
          val fold :
            'Core_kernel.Std.Sequence.t ->
            init:'-> f:('-> '-> 'b) -> 'b
          val fold_left :
            'Core_kernel.Std.Sequence.t ->
            init:'-> f:('-> '-> 'b) -> 'b
          val fold_right :
            'Core_kernel.Std.Sequence.t ->
            f:('-> '-> 'b) -> init:'-> 'b
          val reduce :
            'Core_kernel.Std.Sequence.t -> f:('-> '-> 'a) -> 'a option
          val exists :
            'Core_kernel.Std.Sequence.t -> f:('-> bool) -> bool
          val for_all :
            'Core_kernel.Std.Sequence.t -> f:('-> bool) -> bool
          val count : 'Core_kernel.Std.Sequence.t -> f:('-> bool) -> int
          val map_reduce :
            (module Monoid.S with type t = 'a) ->
            'Core_kernel.Std.Sequence.t -> f:('-> 'a) -> 'a
          val find :
            'Core_kernel.Std.Sequence.t -> f:('-> bool) -> 'a option
          val find_map :
            'Core_kernel.Std.Sequence.t -> f:('-> 'b option) -> 'b option
          val filter :
            'Core_kernel.Std.Sequence.t ->
            f:('-> bool) -> 'Core_kernel.Std.Sequence.t
          val filter_map :
            'Core_kernel.Std.Sequence.t ->
            f:('-> 'b option) -> 'Core_kernel.Std.Sequence.t
        end
      val ( >=> ) : ('-> 'b) -> ('-> 'c) -> '-> 'c
      val ( !! ) : '-> 'a
      val ( !$ ) : ('-> 'b) -> '-> 'b
      val ( !$$ ) : ('-> '-> 'c) -> '-> '-> 'c
      val ( !$$$ ) : ('-> '-> '-> 'd) -> '-> '-> '-> 'd
      val ( !$$$$ ) :
        ('-> '-> '-> '-> 'e) -> '-> '-> '-> '-> 'e
      val ( !$$$$$ ) :
        ('-> '-> '-> '-> '-> 'f) ->
        '-> '-> '-> '-> '-> 'f
      val ( >>= ) : '-> ('-> 'b) -> 'b
      val ( >>| ) : '-> ('-> 'b) -> 'b
      module Monad_infix :
        sig
          val ( >>= ) : '-> ('-> 'b) -> 'b
          val ( >>| ) : '-> ('-> 'b) -> 'b
        end
      val bind : '-> f:('-> 'b) -> 'b
      val return : '-> 'a
      val map : '-> f:('-> 'b) -> 'b
      val join : '-> 'a
      val ignore_m : '-> unit
      val all : 'a list -> 'a list
      val all_ignore : unit list -> unit
      module Let_syntax :
        sig
          val return : '-> 'a
          val ( >>= ) : '-> ('-> 'b) -> 'b
          val ( >>| ) : '-> ('-> 'b) -> 'b
          module Let_syntax :
            sig
              val return : '-> 'a
              val bind : '-> f:('-> 'b) -> 'b
              val map : '-> f:('-> 'b) -> 'b
              val both : '-> '-> 'a * 'b
              module Open_on_rhs : sig  end
            end
        end
      module Syntax :
        sig
          val ( >>= ) : '-> ('-> 'b) -> 'b
          val ( >>| ) : '-> ('-> 'b) -> 'b
          val ( >=> ) : ('-> 'b) -> ('-> 'c) -> '-> 'c
          val ( !! ) : '-> 'a
          val ( !$ ) : ('-> 'b) -> '-> 'b
          val ( !$$ ) : ('-> '-> 'c) -> '-> '-> 'c
          val ( !$$$ ) : ('-> '-> '-> 'd) -> '-> '-> '-> 'd
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) -> '-> '-> '-> '-> 'e
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            '-> '-> '-> '-> '-> 'f
        end
    end
  module Option :
    sig
      module type S =
        sig
          type 'a t
          type 'a m
          type 'a e
          val lift : 'a m -> 'a t
          val run : 'a t -> 'a e
          val void : 'a t -> unit t
          val sequence : unit t list -> unit t
          val forever : 'a t -> 'b t
          module Fn :
            sig
              val id : '-> 'a t
              val ignore : 'a t -> unit t
              val nothing : unit -> unit t
              val non : ('-> bool t) -> '-> bool t
              val apply_n_times : n:int -> ('-> 'a t) -> '-> 'a t
              val compose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
            end
          module Pair :
            sig
              val fst : ('a * 'b) t -> 'a t
              val snd : ('a * 'b) t -> 'b t
            end
          module Triple :
            sig
              val fst : ('a * 'b * 'c) t -> 'a t
              val snd : ('a * 'b * 'c) t -> 'b t
              val trd : ('a * 'b * 'c) t -> 'c t
            end
          module Lift :
            sig
              val nullary : '-> 'a t
              val unary : ('-> 'b) -> 'a t -> 'b t
              val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ternary :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val quaternary :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val quinary :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
            end
          module Exn :
            sig
              val expect :
                ?finally:(unit -> unit t) ->
                f:(unit -> 'a t) -> catch:(exn -> 'a t) -> 'a t
            end
          module Collection :
            sig
              module type S =
                sig
                  type 'a t
                  val all : 'a t t -> 'a t t
                  val all_ignore : 'a t t -> unit t
                  val sequence : unit t t -> unit t
                  val map : 'a t -> f:('-> 'b t) -> 'b t t
                  val iter : 'a t -> f:('-> unit t) -> unit t
                  val fold : 'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce : 'a t -> f:('-> '-> 'a t) -> 'a option t
                  val exists : 'a t -> f:('-> bool t) -> bool t
                  val for_all : 'a t -> f:('-> bool t) -> bool t
                  val count : 'a t -> f:('-> bool t) -> int t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b t -> f:('-> 'a t) -> 'a t
                  val find : 'a t -> f:('-> bool t) -> 'a option t
                  val find_map : 'a t -> f:('-> 'b option t) -> 'b option t
                  val filter : 'a t -> f:('-> bool t) -> 'a t t
                  val filter_map : 'a t -> f:('-> 'b option t) -> 'b t t
                end
              module Eager :
                functor (T : Collection.Eager->
                  sig
                    val all : 'a t T.t -> 'T.t t
                    val all_ignore : 'a t T.t -> unit t
                    val sequence : unit t T.t -> unit t
                    val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                    val iter : 'T.t -> f:('-> unit t) -> unit t
                    val fold :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_left :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_right :
                      'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                    val reduce :
                      'T.t -> f:('-> '-> 'a t) -> 'a option t
                    val exists : 'T.t -> f:('-> bool t) -> bool t
                    val for_all : 'T.t -> f:('-> bool t) -> bool t
                    val count : 'T.t -> f:('-> bool t) -> int t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> 'a t) -> 'a t
                    val find : 'T.t -> f:('-> bool t) -> 'a option t
                    val find_map :
                      'T.t -> f:('-> 'b option t) -> 'b option t
                    val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                    val filter_map :
                      'T.t -> f:('-> 'b option t) -> 'T.t t
                  end
              module Delay :
                functor (T : Collection.Delay->
                  sig
                    val all : 'a t T.t -> 'T.t t
                    val all_ignore : 'a t T.t -> unit t
                    val sequence : unit t T.t -> unit t
                    val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                    val iter : 'T.t -> f:('-> unit t) -> unit t
                    val fold :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_left :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_right :
                      'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                    val reduce :
                      'T.t -> f:('-> '-> 'a t) -> 'a option t
                    val exists : 'T.t -> f:('-> bool t) -> bool t
                    val for_all : 'T.t -> f:('-> bool t) -> bool t
                    val count : 'T.t -> f:('-> bool t) -> int t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> 'a t) -> 'a t
                    val find : 'T.t -> f:('-> bool t) -> 'a option t
                    val find_map :
                      'T.t -> f:('-> 'b option t) -> 'b option t
                    val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                    val filter_map :
                      'T.t -> f:('-> 'b option t) -> 'T.t t
                  end
            end
          module List :
            sig
              val all : 'a t list -> 'a list t
              val all_ignore : 'a t list -> unit t
              val sequence : unit t list -> unit t
              val map : 'a list -> f:('-> 'b t) -> 'b list t
              val iter : 'a list -> f:('-> unit t) -> unit t
              val fold : 'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_left :
                'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_right :
                'a list -> f:('-> '-> 'b t) -> init:'-> 'b t
              val reduce : 'a list -> f:('-> '-> 'a t) -> 'a option t
              val exists : 'a list -> f:('-> bool t) -> bool t
              val for_all : 'a list -> f:('-> bool t) -> bool t
              val count : 'a list -> f:('-> bool t) -> int t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'b list -> f:('-> 'a t) -> 'a t
              val find : 'a list -> f:('-> bool t) -> 'a option t
              val find_map : 'a list -> f:('-> 'b option t) -> 'b option t
              val filter : 'a list -> f:('-> bool t) -> 'a list t
              val filter_map : 'a list -> f:('-> 'b option t) -> 'b list t
            end
          module Seq :
            sig
              val all :
                'a t Core_kernel.Std.Sequence.t ->
                'Core_kernel.Std.Sequence.t t
              val all_ignore : 'a t Core_kernel.Std.Sequence.t -> unit t
              val sequence : unit t Core_kernel.Std.Sequence.t -> unit t
              val map :
                'Core_kernel.Std.Sequence.t ->
                f:('-> 'b t) -> 'Core_kernel.Std.Sequence.t t
              val iter :
                'Core_kernel.Std.Sequence.t -> f:('-> unit t) -> unit t
              val fold :
                'Core_kernel.Std.Sequence.t ->
                init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_left :
                'Core_kernel.Std.Sequence.t ->
                init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_right :
                'Core_kernel.Std.Sequence.t ->
                f:('-> '-> 'b t) -> init:'-> 'b t
              val reduce :
                'Core_kernel.Std.Sequence.t ->
                f:('-> '-> 'a t) -> 'a option t
              val exists :
                'Core_kernel.Std.Sequence.t -> f:('-> bool t) -> bool t
              val for_all :
                'Core_kernel.Std.Sequence.t -> f:('-> bool t) -> bool t
              val count :
                'Core_kernel.Std.Sequence.t -> f:('-> bool t) -> int t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'Core_kernel.Std.Sequence.t -> f:('-> 'a t) -> 'a t
              val find :
                'Core_kernel.Std.Sequence.t ->
                f:('-> bool t) -> 'a option t
              val find_map :
                'Core_kernel.Std.Sequence.t ->
                f:('-> 'b option t) -> 'b option t
              val filter :
                'Core_kernel.Std.Sequence.t ->
                f:('-> bool t) -> 'Core_kernel.Std.Sequence.t t
              val filter_map :
                'Core_kernel.Std.Sequence.t ->
                f:('-> 'b option t) -> 'Core_kernel.Std.Sequence.t t
            end
          val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
          val ( !! ) : '-> 'a t
          val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
          val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
          val ( !$$$ ) :
            ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            'a t -> 'b t -> 'c t -> 'd t -> 'e t
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
          val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
          val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
          module Monad_infix :
            sig
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
            end
          val bind : 'a t -> f:('-> 'b t) -> 'b t
          val return : '-> 'a t
          val map : 'a t -> f:('-> 'b) -> 'b t
          val join : 'a t t -> 'a t
          val ignore_m : 'a t -> unit t
          val all : 'a t list -> 'a list t
          val all_ignore : unit t list -> unit t
          module Let_syntax :
            sig
              val return : '-> 'a t
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              module Let_syntax :
                sig
                  val return : '-> 'a t
                  val bind : 'a t -> f:('-> 'b t) -> 'b t
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val both : 'a t -> 'b t -> ('a * 'b) t
                  module Open_on_rhs : sig  end
                end
            end
          module Syntax :
            sig
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
              val ( !! ) : '-> 'a t
              val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
              val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
            end
          val pure : '-> 'a t
          val accept : '-> 'a t
          val reject : unit -> 'a t
          val guard : bool -> unit t
          val on : bool -> unit t -> unit t
          val unless : bool -> unit t -> unit t
          val zero : unit -> 'a t
          val plus : 'a t -> 'a t -> 'a t
          type 'a error = unit
          val fail : unit -> 'a t
          val catch : 'a t -> (unit -> 'a t) -> 'a t
        end
      module type S2 =
        sig
          type ('a, 'e) t
          type ('a, 'e) m
          type ('a, 'e) e
          val lift : ('a, 'e) m -> ('a, 'e) t
          val run : ('a, 'e) t -> ('a, 'e) e
          val void : ('a, 'e) t -> (unit, 'e) t
          val sequence : (unit, 'e) t list -> (unit, 'e) t
          val forever : ('a, 'e) t -> ('b, 'e) t
          module Fn :
            sig
              val id : '-> ('a, 'e) t
              val ignore : ('a, 'e) t -> (unit, 'e) t
              val nothing : unit -> (unit, 'e) t
              val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
              val apply_n_times :
                n:int -> ('-> ('a, 'e) t) -> '-> ('a, 'e) t
              val compose :
                ('-> ('c, 'e) t) -> ('-> ('b, 'e) t) -> '-> ('c, 'e) t
            end
          module Pair :
            sig
              val fst : ('a * 'b, 'e) t -> ('a, 'e) t
              val snd : ('a * 'b, 'e) t -> ('b, 'e) t
            end
          module Triple :
            sig
              val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
              val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
              val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
            end
          module Lift :
            sig
              val nullary : '-> ('a, 'e) t
              val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val binary :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ternary :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val quaternary :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val quinary :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
            end
          module Exn :
            sig
              val expect :
                ?finally:(unit -> (unit, 's) t) ->
                f:(unit -> ('a, 's) t) ->
                catch:(exn -> ('a, 's) t) -> ('a, 's) t
            end
          module Collection :
            sig
              module type S =
                sig
                  type 'a t
                  val all : ('a, 'e) t t -> ('a t, 'e) t
                  val all_ignore : ('a, 'e) t t -> (unit, 'e) t
                  val sequence : (unit, 'e) t t -> (unit, 'e) t
                  val map : 'a t -> f:('-> ('b, 'e) t) -> ('b t, 'e) t
                  val iter : 'a t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                  val fold :
                    'a t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'a t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'a t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'a t -> f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                  val exists : 'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count : 'a t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'a t -> f:('-> (bool, 'e) t) -> ('a option, 'e) t
                  val find_map :
                    'a t -> f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                  val filter : 'a t -> f:('-> (bool, 'e) t) -> ('a t, 'e) t
                  val filter_map :
                    'a t -> f:('-> ('b option, 'e) t) -> ('b t, 'e) t
                end
              module Eager :
                functor (T : Collection.Eager->
                  sig
                    val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                    val all_ignore : ('a, 'e) t T.t -> (unit, 'e) t
                    val sequence : (unit, 'e) t T.t -> (unit, 'e) t
                    val map :
                      'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                    val iter :
                      'T.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                    val fold :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_left :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_right :
                      'T.t ->
                      f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                    val reduce :
                      'T.t ->
                      f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                    val exists :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val for_all :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val count :
                      'T.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                    val find :
                      'T.t -> f:('-> (bool, 'e) t) -> ('a option, 'e) t
                    val find_map :
                      'T.t ->
                      f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                    val filter :
                      'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                    val filter_map :
                      'T.t -> f:('-> ('b option, 'e) t) -> ('T.t, 'e) t
                  end
              module Delay :
                functor (T : Collection.Delay->
                  sig
                    val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                    val all_ignore : ('a, 'e) t T.t -> (unit, 'e) t
                    val sequence : (unit, 'e) t T.t -> (unit, 'e) t
                    val map :
                      'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                    val iter :
                      'T.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                    val fold :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_left :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_right :
                      'T.t ->
                      f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                    val reduce :
                      'T.t ->
                      f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                    val exists :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val for_all :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val count :
                      'T.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                    val find :
                      'T.t -> f:('-> (bool, 'e) t) -> ('a option, 'e) t
                    val find_map :
                      'T.t ->
                      f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                    val filter :
                      'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                    val filter_map :
                      'T.t -> f:('-> ('b option, 'e) t) -> ('T.t, 'e) t
                  end
            end
          module List :
            sig
              val all : ('a, 'e) t list -> ('a list, 'e) t
              val all_ignore : ('a, 'e) t list -> (unit, 'e) t
              val sequence : (unit, 'e) t list -> (unit, 'e) t
              val map : 'a list -> f:('-> ('b, 'e) t) -> ('b list, 'e) t
              val iter : 'a list -> f:('-> (unit, 'e) t) -> (unit, 'e) t
              val fold :
                'a list ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_left :
                'a list ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_right :
                'a list ->
                f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
              val reduce :
                'a list -> f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
              val exists : 'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val for_all : 'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val count : 'a list -> f:('-> (bool, 'e) t) -> (int, 'e) t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'b list -> f:('-> ('a, 'e) t) -> ('a, 'e) t
              val find :
                'a list -> f:('-> (bool, 'e) t) -> ('a option, 'e) t
              val find_map :
                'a list -> f:('-> ('b option, 'e) t) -> ('b option, 'e) t
              val filter :
                'a list -> f:('-> (bool, 'e) t) -> ('a list, 'e) t
              val filter_map :
                'a list -> f:('-> ('b option, 'e) t) -> ('b list, 'e) t
            end
          module Seq :
            sig
              val all :
                ('a, 'e) t Core_kernel.Std.Sequence.t ->
                ('Core_kernel.Std.Sequence.t, 'e) t
              val all_ignore :
                ('a, 'e) t Core_kernel.Std.Sequence.t -> (unit, 'e) t
              val sequence :
                (unit, 'e) t Core_kernel.Std.Sequence.t -> (unit, 'e) t
              val map :
                'Core_kernel.Std.Sequence.t ->
                f:('-> ('b, 'e) t) -> ('Core_kernel.Std.Sequence.t, 'e) t
              val iter :
                'Core_kernel.Std.Sequence.t ->
                f:('-> (unit, 'e) t) -> (unit, 'e) t
              val fold :
                'Core_kernel.Std.Sequence.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_left :
                'Core_kernel.Std.Sequence.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_right :
                'Core_kernel.Std.Sequence.t ->
                f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
              val reduce :
                'Core_kernel.Std.Sequence.t ->
                f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
              val exists :
                'Core_kernel.Std.Sequence.t ->
                f:('-> (bool, 'e) t) -> (bool, 'e) t
              val for_all :
                'Core_kernel.Std.Sequence.t ->
                f:('-> (bool, 'e) t) -> (bool, 'e) t
              val count :
                'Core_kernel.Std.Sequence.t ->
                f:('-> (bool, 'e) t) -> (int, 'e) t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'Core_kernel.Std.Sequence.t ->
                f:('-> ('a, 'e) t) -> ('a, 'e) t
              val find :
                'Core_kernel.Std.Sequence.t ->
                f:('-> (bool, 'e) t) -> ('a option, 'e) t
              val find_map :
                'Core_kernel.Std.Sequence.t ->
                f:('-> ('b option, 'e) t) -> ('b option, 'e) t
              val filter :
                'Core_kernel.Std.Sequence.t ->
                f:('-> (bool, 'e) t) ->
                ('Core_kernel.Std.Sequence.t, 'e) t
              val filter_map :
                'Core_kernel.Std.Sequence.t ->
                f:('-> ('b option, 'e) t) ->
                ('Core_kernel.Std.Sequence.t, 'e) t
            end
          val ( >=> ) :
            ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
          val ( !! ) : '-> ('a, 'e) t
          val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
          val ( !$$ ) :
            ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
          val ( !$$$ ) :
            ('-> '-> '-> 'd) ->
            ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            ('a, 's) t ->
            ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            ('a, 's) t ->
            ('b, 's) t ->
            ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
          val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
          val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
          module Let_syntax :
            sig
              val return : '-> ('a, 'b) t
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              module Let_syntax :
                sig
                  val return : '-> ('a, 'b) t
                  val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                  val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                  val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                  module Open_on_rhs : sig  end
                end
            end
          module Monad_infix :
            sig
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
            end
          val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
          val return : '-> ('a, 'b) t
          val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
          val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
          val ignore_m : ('a, 'e) t -> (unit, 'e) t
          val all : ('a, 'e) t list -> ('a list, 'e) t
          val all_ignore : (unit, 'e) t list -> (unit, 'e) t
          module Syntax :
            sig
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              val ( >=> ) :
                ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
              val ( !! ) : '-> ('a, 'e) t
              val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val ( !$$ ) :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
            end
          val pure : '-> ('a, 'e) t
          val accept : '-> ('a, 'e) t
          val reject : unit -> ('a, 'e) t
          val guard : bool -> (unit, 'e) t
          val on : bool -> (unit, 'e) t -> (unit, 'e) t
          val unless : bool -> (unit, 'e) t -> (unit, 'e) t
          val zero : unit -> ('a, 'e) t
          val plus : ('a, 'e) t -> ('a, 'e) t -> ('a, 'e) t
          type 'a error = unit
          val fail : unit -> ('a, 'e) t
          val catch : ('a, 'e) t -> (unit -> ('a, 'e) t) -> ('a, 'e) t
        end
      type 'a t = 'a option
      type 'a m = 'a
      type 'a e = 'a t
      val lift : '-> 'a e
      val run : 'a e -> 'a e
      val void : 'a e -> unit e
      val sequence : unit e list -> unit e
      val forever : 'a e -> 'b e
      module Fn :
        sig
          val id : '-> 'a e
          val ignore : 'a e -> unit e
          val nothing : unit -> unit e
          val non : ('-> bool e) -> '-> bool e
          val apply_n_times : n:int -> ('-> 'a e) -> '-> 'a e
          val compose : ('-> 'c e) -> ('-> 'b e) -> '-> 'c e
        end
      module Pair :
        sig val fst : ('a * 'b) e -> 'a e val snd : ('a * 'b) e -> 'b e end
      module Triple :
        sig
          val fst : ('a * 'b * 'c) e -> 'a e
          val snd : ('a * 'b * 'c) e -> 'b e
          val trd : ('a * 'b * 'c) e -> 'c e
        end
      module Lift :
        sig
          val nullary : '-> 'a e
          val unary : ('-> 'b) -> 'a e -> 'b e
          val binary : ('-> '-> 'c) -> 'a e -> 'b e -> 'c e
          val ternary :
            ('-> '-> '-> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
          val quaternary :
            ('-> '-> '-> '-> 'e) ->
            'a e -> 'b e -> 'c e -> 'd e -> 'e e
          val quinary :
            ('-> '-> '-> '-> '-> 'f) ->
            'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
        end
      module Exn :
        sig
          val expect :
            ?finally:(unit -> unit e) ->
            f:(unit -> 'a e) -> catch:(exn -> 'a e) -> 'a e
        end
      module Collection :
        sig
          module type S =
            sig
              type 'a t
              val all : 'a e t -> 'a t e
              val all_ignore : 'a e t -> unit e
              val sequence : unit e t -> unit e
              val map : 'a t -> f:('-> 'b e) -> 'b t e
              val iter : 'a t -> f:('-> unit e) -> unit e
              val fold : 'a t -> init:'-> f:('-> '-> 'b e) -> 'b e
              val fold_left : 'a t -> init:'-> f:('-> '-> 'b e) -> 'b e
              val fold_right :
                'a t -> f:('-> '-> 'b e) -> init:'-> 'b e
              val reduce : 'a t -> f:('-> '-> 'a e) -> 'a e e
              val exists : 'a t -> f:('-> bool e) -> bool e
              val for_all : 'a t -> f:('-> bool e) -> bool e
              val count : 'a t -> f:('-> bool e) -> int e
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'b t -> f:('-> 'a e) -> 'a e
              val find : 'a t -> f:('-> bool e) -> 'a e e
              val find_map : 'a t -> f:('-> 'b e e) -> 'b e e
              val filter : 'a t -> f:('-> bool e) -> 'a t e
              val filter_map : 'a t -> f:('-> 'b e e) -> 'b t e
            end
          module Eager :
            functor (T : Collection.Eager->
              sig
                val all : 'a e T.t -> 'T.t e
                val all_ignore : 'a e T.t -> unit e
                val sequence : unit e T.t -> unit e
                val map : 'T.t -> f:('-> 'b e) -> 'T.t e
                val iter : 'T.t -> f:('-> unit e) -> unit e
                val fold : 'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                val fold_left :
                  'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                val fold_right :
                  'T.t -> f:('-> '-> 'b e) -> init:'-> 'b e
                val reduce : 'T.t -> f:('-> '-> 'a e) -> 'a e e
                val exists : 'T.t -> f:('-> bool e) -> bool e
                val for_all : 'T.t -> f:('-> bool e) -> bool e
                val count : 'T.t -> f:('-> bool e) -> int e
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'T.t -> f:('-> 'a e) -> 'a e
                val find : 'T.t -> f:('-> bool e) -> 'a e e
                val find_map : 'T.t -> f:('-> 'b e e) -> 'b e e
                val filter : 'T.t -> f:('-> bool e) -> 'T.t e
                val filter_map : 'T.t -> f:('-> 'b e e) -> 'T.t e
              end
          module Delay :
            functor (T : Collection.Delay->
              sig
                val all : 'a e T.t -> 'T.t e
                val all_ignore : 'a e T.t -> unit e
                val sequence : unit e T.t -> unit e
                val map : 'T.t -> f:('-> 'b e) -> 'T.t e
                val iter : 'T.t -> f:('-> unit e) -> unit e
                val fold : 'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                val fold_left :
                  'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                val fold_right :
                  'T.t -> f:('-> '-> 'b e) -> init:'-> 'b e
                val reduce : 'T.t -> f:('-> '-> 'a e) -> 'a e e
                val exists : 'T.t -> f:('-> bool e) -> bool e
                val for_all : 'T.t -> f:('-> bool e) -> bool e
                val count : 'T.t -> f:('-> bool e) -> int e
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'T.t -> f:('-> 'a e) -> 'a e
                val find : 'T.t -> f:('-> bool e) -> 'a e e
                val find_map : 'T.t -> f:('-> 'b e e) -> 'b e e
                val filter : 'T.t -> f:('-> bool e) -> 'T.t e
                val filter_map : 'T.t -> f:('-> 'b e e) -> 'T.t e
              end
        end
      module List :
        sig
          val all : 'a e list -> 'a list e
          val all_ignore : 'a e list -> unit e
          val sequence : unit e list -> unit e
          val map : 'a list -> f:('-> 'b e) -> 'b list e
          val iter : 'a list -> f:('-> unit e) -> unit e
          val fold : 'a list -> init:'-> f:('-> '-> 'b e) -> 'b e
          val fold_left : 'a list -> init:'-> f:('-> '-> 'b e) -> 'b e
          val fold_right : 'a list -> f:('-> '-> 'b e) -> init:'-> 'b e
          val reduce : 'a list -> f:('-> '-> 'a e) -> 'a e e
          val exists : 'a list -> f:('-> bool e) -> bool e
          val for_all : 'a list -> f:('-> bool e) -> bool e
          val count : 'a list -> f:('-> bool e) -> int e
          val map_reduce :
            (module Monoid.S with type t = 'a) ->
            'b list -> f:('-> 'a e) -> 'a e
          val find : 'a list -> f:('-> bool e) -> 'a e e
          val find_map : 'a list -> f:('-> 'b e e) -> 'b e e
          val filter : 'a list -> f:('-> bool e) -> 'a list e
          val filter_map : 'a list -> f:('-> 'b e e) -> 'b list e
        end
      module Seq :
        sig
          val all :
            'a e Core_kernel.Std.Sequence.t ->
            'Core_kernel.Std.Sequence.t e
          val all_ignore : 'a e Core_kernel.Std.Sequence.t -> unit e
          val sequence : unit e Core_kernel.Std.Sequence.t -> unit e
          val map :
            'Core_kernel.Std.Sequence.t ->
            f:('-> 'b e) -> 'Core_kernel.Std.Sequence.t e
          val iter :
            'Core_kernel.Std.Sequence.t -> f:('-> unit e) -> unit e
          val fold :
            'Core_kernel.Std.Sequence.t ->
            init:'-> f:('-> '-> 'b e) -> 'b e
          val fold_left :
            'Core_kernel.Std.Sequence.t ->
            init:'-> f:('-> '-> 'b e) -> 'b e
          val fold_right :
            'Core_kernel.Std.Sequence.t ->
            f:('-> '-> 'b e) -> init:'-> 'b e
          val reduce :
            'Core_kernel.Std.Sequence.t -> f:('-> '-> 'a e) -> 'a e e
          val exists :
            'Core_kernel.Std.Sequence.t -> f:('-> bool e) -> bool e
          val for_all :
            'Core_kernel.Std.Sequence.t -> f:('-> bool e) -> bool e
          val count :
            'Core_kernel.Std.Sequence.t -> f:('-> bool e) -> int e
          val map_reduce :
            (module Monoid.S with type t = 'a) ->
            'Core_kernel.Std.Sequence.t -> f:('-> 'a e) -> 'a e
          val find :
            'Core_kernel.Std.Sequence.t -> f:('-> bool e) -> 'a e e
          val find_map :
            'Core_kernel.Std.Sequence.t -> f:('-> 'b e e) -> 'b e e
          val filter :
            'Core_kernel.Std.Sequence.t ->
            f:('-> bool e) -> 'Core_kernel.Std.Sequence.t e
          val filter_map :
            'Core_kernel.Std.Sequence.t ->
            f:('-> 'b e e) -> 'Core_kernel.Std.Sequence.t e
        end
      val ( >=> ) : ('-> 'b e) -> ('-> 'c e) -> '-> 'c e
      val ( !! ) : '-> 'a e
      val ( !$ ) : ('-> 'b) -> 'a e -> 'b e
      val ( !$$ ) : ('-> '-> 'c) -> 'a e -> 'b e -> 'c e
      val ( !$$$ ) : ('-> '-> '-> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
      val ( !$$$$ ) :
        ('-> '-> '-> '-> 'e) -> 'a e -> 'b e -> 'c e -> 'd e -> 'e e
      val ( !$$$$$ ) :
        ('-> '-> '-> '-> '-> 'f) ->
        'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
      val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
      val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
      module Monad_infix :
        sig
          val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
          val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
        end
      val bind : 'a e -> f:('-> 'b e) -> 'b e
      val return : '-> 'a e
      val map : 'a e -> f:('-> 'b) -> 'b e
      val join : 'a e e -> 'a e
      val ignore_m : 'a e -> unit e
      val all : 'a e list -> 'a list e
      val all_ignore : unit e list -> unit e
      module Let_syntax :
        sig
          val return : '-> 'a e
          val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
          val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
          module Let_syntax :
            sig
              val return : '-> 'a e
              val bind : 'a e -> f:('-> 'b e) -> 'b e
              val map : 'a e -> f:('-> 'b) -> 'b e
              val both : 'a e -> 'b e -> ('a * 'b) e
              module Open_on_rhs : sig  end
            end
        end
      module Syntax :
        sig
          val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
          val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
          val ( >=> ) : ('-> 'b e) -> ('-> 'c e) -> '-> 'c e
          val ( !! ) : '-> 'a e
          val ( !$ ) : ('-> 'b) -> 'a e -> 'b e
          val ( !$$ ) : ('-> '-> 'c) -> 'a e -> 'b e -> 'c e
          val ( !$$$ ) :
            ('-> '-> '-> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            'a e -> 'b e -> 'c e -> 'd e -> 'e e
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
        end
      val pure : '-> 'a e
      val accept : '-> 'a e
      val reject : unit -> 'a e
      val guard : bool -> unit e
      val on : bool -> unit e -> unit e
      val unless : bool -> unit e -> unit e
      val zero : unit -> 'a e
      val plus : 'a e -> 'a e -> 'a e
      type 'a error = unit
      val fail : unit -> 'a e
      val catch : 'a e -> (unit -> 'a e) -> 'a e
      module T1 :
        functor (M : Core_kernel.Std.T1->
          sig
            type 'a t = 'a e M.t
            type 'a m = 'M.t
            type 'a e = 'Monads.Std.Monad.Option.T1.t
          end
      module T2 :
        functor (M : Core_kernel.Std.T2->
          sig
            type ('a, 'e) t = ('a e, 'e) M.t
            type ('a, 'e) m = ('a, 'e) M.t
            type ('a, 'e) e = ('a, 'e) Monads.Std.Monad.Option.T2.t
          end
      module Make :
        functor (M : Monad->
          sig
            val lift : 'M.t -> 'T1(M).t
            val run : 'T1(M).t -> 'Monads.Std.Monad.Option.T1.t
            val void : 'T1(M).t -> unit T1(M).t
            val sequence : unit T1(M).t list -> unit T1(M).t
            val forever : 'T1(M).t -> 'T1(M).t
            module Fn :
              sig
                val id : '-> 'T1(M).t
                val ignore : 'T1(M).t -> unit T1(M).t
                val nothing : unit -> unit T1(M).t
                val non : ('-> bool T1(M).t) -> '-> bool T1(M).t
                val apply_n_times :
                  n:int -> ('-> 'T1(M).t) -> '-> 'T1(M).t
                val compose :
                  ('-> 'T1(M).t) ->
                  ('-> 'T1(M).t) -> '-> 'T1(M).t
              end
            module Pair :
              sig
                val fst : ('a * 'b) T1(M).t -> 'T1(M).t
                val snd : ('a * 'b) T1(M).t -> 'T1(M).t
              end
            module Triple :
              sig
                val fst : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                val snd : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                val trd : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
              end
            module Lift :
              sig
                val nullary : '-> 'T1(M).t
                val unary : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                val binary :
                  ('-> '-> 'c) -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ternary :
                  ('-> '-> '-> 'd) ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val quaternary :
                  ('-> '-> '-> '-> 'e) ->
                  'T1(M).t ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val quinary :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'T1(M).t ->
                  'T1(M).t ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
              end
            module Exn :
              sig
                val expect :
                  ?finally:(unit -> unit T1(M).t) ->
                  f:(unit -> 'T1(M).t) ->
                  catch:(exn -> 'T1(M).t) -> 'T1(M).t
              end
            module Collection :
              sig
                module type S =
                  sig
                    type 'a t
                    val all : 'T1(M).t t -> 'a t T1(M).t
                    val all_ignore : 'T1(M).t t -> unit T1(M).t
                    val sequence : unit T1(M).t t -> unit T1(M).t
                    val map : 'a t -> f:('-> 'T1(M).t) -> 'b t T1(M).t
                    val iter : 'a t -> f:('-> unit T1(M).t) -> unit T1(M).t
                    val fold :
                      'a t ->
                      init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                    val fold_left :
                      'a t ->
                      init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                    val fold_right :
                      'a t ->
                      f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                    val reduce :
                      'a t -> f:('-> '-> 'T1(M).t) -> 'a e T1(M).t
                    val exists :
                      'a t -> f:('-> bool T1(M).t) -> bool T1(M).t
                    val for_all :
                      'a t -> f:('-> bool T1(M).t) -> bool T1(M).t
                    val count : 'a t -> f:('-> bool T1(M).t) -> int T1(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b t -> f:('-> 'T1(M).t) -> 'T1(M).t
                    val find : 'a t -> f:('-> bool T1(M).t) -> 'a e T1(M).t
                    val find_map :
                      'a t -> f:('-> 'b e T1(M).t) -> 'b e T1(M).t
                    val filter :
                      'a t -> f:('-> bool T1(M).t) -> 'a t T1(M).t
                    val filter_map :
                      'a t -> f:('-> 'b e T1(M).t) -> 'b t T1(M).t
                  end
                module Eager :
                  functor (T : Collection.Eager->
                    sig
                      val all : 'T1(M).t T.t -> 'T.t T1(M).t
                      val all_ignore : 'T1(M).t T.t -> unit T1(M).t
                      val sequence : unit T1(M).t T.t -> unit T1(M).t
                      val map :
                        'T.t -> f:('-> 'T1(M).t) -> 'T.t T1(M).t
                      val iter :
                        'T.t -> f:('-> unit T1(M).t) -> unit T1(M).t
                      val fold :
                        'T.t ->
                        init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                      val fold_left :
                        'T.t ->
                        init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                      val reduce :
                        'T.t -> f:('-> '-> 'T1(M).t) -> 'a e T1(M).t
                      val exists :
                        'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                      val for_all :
                        'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                      val count :
                        'T.t -> f:('-> bool T1(M).t) -> int T1(M).t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t -> f:('-> 'T1(M).t) -> 'T1(M).t
                      val find :
                        'T.t -> f:('-> bool T1(M).t) -> 'a e T1(M).t
                      val find_map :
                        'T.t -> f:('-> 'b e T1(M).t) -> 'b e T1(M).t
                      val filter :
                        'T.t -> f:('-> bool T1(M).t) -> 'T.t T1(M).t
                      val filter_map :
                        'T.t -> f:('-> 'b e T1(M).t) -> 'T.t T1(M).t
                    end
                module Delay :
                  functor (T : Collection.Delay->
                    sig
                      val all : 'T1(M).t T.t -> 'T.t T1(M).t
                      val all_ignore : 'T1(M).t T.t -> unit T1(M).t
                      val sequence : unit T1(M).t T.t -> unit T1(M).t
                      val map :
                        'T.t -> f:('-> 'T1(M).t) -> 'T.t T1(M).t
                      val iter :
                        'T.t -> f:('-> unit T1(M).t) -> unit T1(M).t
                      val fold :
                        'T.t ->
                        init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                      val fold_left :
                        'T.t ->
                        init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                      val reduce :
                        'T.t -> f:('-> '-> 'T1(M).t) -> 'a e T1(M).t
                      val exists :
                        'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                      val for_all :
                        'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                      val count :
                        'T.t -> f:('-> bool T1(M).t) -> int T1(M).t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t -> f:('-> 'T1(M).t) -> 'T1(M).t
                      val find :
                        'T.t -> f:('-> bool T1(M).t) -> 'a e T1(M).t
                      val find_map :
                        'T.t -> f:('-> 'b e T1(M).t) -> 'b e T1(M).t
                      val filter :
                        'T.t -> f:('-> bool T1(M).t) -> 'T.t T1(M).t
                      val filter_map :
                        'T.t -> f:('-> 'b e T1(M).t) -> 'T.t T1(M).t
                    end
              end
            module List :
              sig
                val all : 'T1(M).t list -> 'a list T1(M).t
                val all_ignore : 'T1(M).t list -> unit T1(M).t
                val sequence : unit T1(M).t list -> unit T1(M).t
                val map : 'a list -> f:('-> 'T1(M).t) -> 'b list T1(M).t
                val iter : 'a list -> f:('-> unit T1(M).t) -> unit T1(M).t
                val fold :
                  'a list ->
                  init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                val fold_left :
                  'a list ->
                  init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                val fold_right :
                  'a list ->
                  f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                val reduce :
                  'a list -> f:('-> '-> 'T1(M).t) -> 'a e T1(M).t
                val exists :
                  'a list -> f:('-> bool T1(M).t) -> bool T1(M).t
                val for_all :
                  'a list -> f:('-> bool T1(M).t) -> bool T1(M).t
                val count : 'a list -> f:('-> bool T1(M).t) -> int T1(M).t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'b list -> f:('-> 'T1(M).t) -> 'T1(M).t
                val find : 'a list -> f:('-> bool T1(M).t) -> 'a e T1(M).t
                val find_map :
                  'a list -> f:('-> 'b e T1(M).t) -> 'b e T1(M).t
                val filter :
                  'a list -> f:('-> bool T1(M).t) -> 'a list T1(M).t
                val filter_map :
                  'a list -> f:('-> 'b e T1(M).t) -> 'b list T1(M).t
              end
            module Seq :
              sig
                val all :
                  'T1(M).t Core_kernel.Std.Sequence.t ->
                  'Core_kernel.Std.Sequence.t T1(M).t
                val all_ignore :
                  'T1(M).t Core_kernel.Std.Sequence.t -> unit T1(M).t
                val sequence :
                  unit T1(M).t Core_kernel.Std.Sequence.t -> unit T1(M).t
                val map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> 'T1(M).t) ->
                  'Core_kernel.Std.Sequence.t T1(M).t
                val iter :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> unit T1(M).t) -> unit T1(M).t
                val fold :
                  'Core_kernel.Std.Sequence.t ->
                  init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                val fold_left :
                  'Core_kernel.Std.Sequence.t ->
                  init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                val fold_right :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                val reduce :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> '-> 'T1(M).t) -> 'a e T1(M).t
                val exists :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(M).t) -> bool T1(M).t
                val for_all :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(M).t) -> bool T1(M).t
                val count :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(M).t) -> int T1(M).t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> 'T1(M).t) -> 'T1(M).t
                val find :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(M).t) -> 'a e T1(M).t
                val find_map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> 'b e T1(M).t) -> 'b e T1(M).t
                val filter :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(M).t) ->
                  'Core_kernel.Std.Sequence.t T1(M).t
                val filter_map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> 'b e T1(M).t) ->
                  'Core_kernel.Std.Sequence.t T1(M).t
              end
            val ( >=> ) :
              ('-> 'T1(M).t) -> ('-> 'T1(M).t) -> '-> 'T1(M).t
            val ( !! ) : '-> 'T1(M).t
            val ( !$ ) : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
            val ( !$$ ) :
              ('-> '-> 'c) -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
            val ( !$$$ ) :
              ('-> '-> '-> 'd) ->
              'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
            val ( !$$$$ ) :
              ('-> '-> '-> '-> 'e) ->
              'T1(M).t ->
              'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
            val ( !$$$$$ ) :
              ('-> '-> '-> '-> '-> 'f) ->
              'T1(M).t ->
              'T1(M).t ->
              'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
            val ( >>= ) : 'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
            val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
            module Monad_infix :
              sig
                val ( >>= ) : 'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
              end
            val bind : 'T1(M).t -> f:('-> 'T1(M).t) -> 'T1(M).t
            val return : '-> 'T1(M).t
            val map : 'T1(M).t -> f:('-> 'b) -> 'T1(M).t
            val join : 'T1(M).t T1(M).t -> 'T1(M).t
            val ignore_m : 'T1(M).t -> unit T1(M).t
            val all : 'T1(M).t list -> 'a list T1(M).t
            val all_ignore : unit T1(M).t list -> unit T1(M).t
            module Let_syntax :
              sig
                val return : '-> 'T1(M).t
                val ( >>= ) : 'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                module Let_syntax :
                  sig
                    val return : '-> 'T1(M).t
                    val bind :
                      'T1(M).t -> f:('-> 'T1(M).t) -> 'T1(M).t
                    val map : 'T1(M).t -> f:('-> 'b) -> 'T1(M).t
                    val both : 'T1(M).t -> 'T1(M).t -> ('a * 'b) T1(M).t
                    module Open_on_rhs : sig  end
                  end
              end
            module Syntax :
              sig
                val ( >>= ) : 'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                val ( >=> ) :
                  ('-> 'T1(M).t) ->
                  ('-> 'T1(M).t) -> '-> 'T1(M).t
                val ( !! ) : '-> 'T1(M).t
                val ( !$ ) : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  'T1(M).t ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'T1(M).t ->
                  'T1(M).t ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
              end
            val pure : '-> 'T1(M).t
            val accept : '-> 'T1(M).t
            val reject : unit -> 'T1(M).t
            val guard : bool -> unit T1(M).t
            val on : bool -> unit T1(M).t -> unit T1(M).t
            val unless : bool -> unit T1(M).t -> unit T1(M).t
            val zero : unit -> 'T1(M).t
            val plus : 'T1(M).t -> 'T1(M).t -> 'T1(M).t
            type 'a error = unit
            val fail : unit -> 'T1(M).t
            val catch : 'T1(M).t -> (unit -> 'T1(M).t) -> 'T1(M).t
          end
      module Make2 :
        functor (M : Monad2->
          sig
            val lift : ('a, 'e) M.t -> ('a, 'e) T2(M).t
            val run :
              ('a, 'e) T2(M).t -> ('a, 'e) Monads.Std.Monad.Option.T2.t
            val void : ('a, 'e) T2(M).t -> (unit, 'e) T2(M).t
            val sequence : (unit, 'e) T2(M).t list -> (unit, 'e) T2(M).t
            val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
            module Fn :
              sig
                val id : '-> ('a, 'e) T2(M).t
                val ignore : ('a, 'e) T2(M).t -> (unit, 'e) T2(M).t
                val nothing : unit -> (unit, 'e) T2(M).t
                val non :
                  ('-> (bool, 'e) T2(M).t) -> '-> (bool, 'e) T2(M).t
                val apply_n_times :
                  n:int -> ('-> ('a, 'e) T2(M).t) -> '-> ('a, 'e) T2(M).t
                val compose :
                  ('-> ('c, 'e) T2(M).t) ->
                  ('-> ('b, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
              end
            module Pair :
              sig
                val fst : ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
                val snd : ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
              end
            module Triple :
              sig
                val fst : ('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
                val snd : ('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
                val trd : ('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
              end
            module Lift :
              sig
                val nullary : '-> ('a, 'e) T2(M).t
                val unary :
                  ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                val binary :
                  ('-> '-> 'c) ->
                  ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                val ternary :
                  ('-> '-> '-> 'd) ->
                  ('a, 'e) T2(M).t ->
                  ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                val quaternary :
                  ('-> '-> '-> '-> 'e) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t -> ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                val quinary :
                  ('-> '-> '-> '-> '-> 'f) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t ->
                  ('d, 's) T2(M).t -> ('e, 's) T2(M).t -> ('f, 's) T2(M).t
              end
            module Exn :
              sig
                val expect :
                  ?finally:(unit -> (unit, 's) T2(M).t) ->
                  f:(unit -> ('a, 's) T2(M).t) ->
                  catch:(exn -> ('a, 's) T2(M).t) -> ('a, 's) T2(M).t
              end
            module Collection :
              sig
                module type S =
                  sig
                    type 'a t
                    val all : ('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
                    val all_ignore : ('a, 'e) T2(M).t t -> (unit, 'e) T2(M).t
                    val sequence : (unit, 'e) T2(M).t t -> (unit, 'e) T2(M).t
                    val map :
                      'a t ->
                      f:('-> ('b, 'e) T2(M).t) -> ('b t, 'e) T2(M).t
                    val iter :
                      'a t ->
                      f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                    val fold :
                      'a t ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_left :
                      'a t ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_right :
                      'a t ->
                      f:('-> '-> ('b, 'e) T2(M).t) ->
                      init:'-> ('b, 'e) T2(M).t
                    val reduce :
                      'a t ->
                      f:('-> '-> ('a, 'e) T2(M).t) -> ('a e, 'e) T2(M).t
                    val exists :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val for_all :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val count :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b t -> f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                    val find :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) -> ('a e, 'e) T2(M).t
                    val find_map :
                      'a t ->
                      f:('-> ('b e, 'e) T2(M).t) -> ('b e, 'e) T2(M).t
                    val filter :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) -> ('a t, 'e) T2(M).t
                    val filter_map :
                      'a t ->
                      f:('-> ('b e, 'e) T2(M).t) -> ('b t, 'e) T2(M).t
                  end
                module Eager :
                  functor (T : Collection.Eager->
                    sig
                      val all : ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                      val all_ignore :
                        ('a, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                      val sequence :
                        (unit, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                      val map :
                        'T.t ->
                        f:('-> ('b, 'e) T2(M).t) -> ('T.t, 'e) T2(M).t
                      val iter :
                        'T.t ->
                        f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                      val fold :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                      val fold_left :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> ('b, 'e) T2(M).t) ->
                        init:'-> ('b, 'e) T2(M).t
                      val reduce :
                        'T.t ->
                        f:('-> '-> ('a, 'e) T2(M).t) ->
                        ('a e, 'e) T2(M).t
                      val exists :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                      val for_all :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                      val count :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t ->
                        f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                      val find :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> ('a e, 'e) T2(M).t
                      val find_map :
                        'T.t ->
                        f:('-> ('b e, 'e) T2(M).t) -> ('b e, 'e) T2(M).t
                      val filter :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> ('T.t, 'e) T2(M).t
                      val filter_map :
                        'T.t ->
                        f:('-> ('b e, 'e) T2(M).t) -> ('T.t, 'e) T2(M).t
                    end
                module Delay :
                  functor (T : Collection.Delay->
                    sig
                      val all : ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                      val all_ignore :
                        ('a, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                      val sequence :
                        (unit, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                      val map :
                        'T.t ->
                        f:('-> ('b, 'e) T2(M).t) -> ('T.t, 'e) T2(M).t
                      val iter :
                        'T.t ->
                        f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                      val fold :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                      val fold_left :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> ('b, 'e) T2(M).t) ->
                        init:'-> ('b, 'e) T2(M).t
                      val reduce :
                        'T.t ->
                        f:('-> '-> ('a, 'e) T2(M).t) ->
                        ('a e, 'e) T2(M).t
                      val exists :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                      val for_all :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                      val count :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t ->
                        f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                      val find :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> ('a e, 'e) T2(M).t
                      val find_map :
                        'T.t ->
                        f:('-> ('b e, 'e) T2(M).t) -> ('b e, 'e) T2(M).t
                      val filter :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> ('T.t, 'e) T2(M).t
                      val filter_map :
                        'T.t ->
                        f:('-> ('b e, 'e) T2(M).t) -> ('T.t, 'e) T2(M).t
                    end
              end
            module List :
              sig
                val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                val all_ignore : ('a, 'e) T2(M).t list -> (unit, 'e) T2(M).t
                val sequence : (unit, 'e) T2(M).t list -> (unit, 'e) T2(M).t
                val map :
                  'a list ->
                  f:('-> ('b, 'e) T2(M).t) -> ('b list, 'e) T2(M).t
                val iter :
                  'a list ->
                  f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                val fold :
                  'a list ->
                  init:'->
                  f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val fold_left :
                  'a list ->
                  init:'->
                  f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val fold_right :
                  'a list ->
                  f:('-> '-> ('b, 'e) T2(M).t) ->
                  init:'-> ('b, 'e) T2(M).t
                val reduce :
                  'a list ->
                  f:('-> '-> ('a, 'e) T2(M).t) -> ('a e, 'e) T2(M).t
                val exists :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                val for_all :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                val count :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'b list -> f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                val find :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> ('a e, 'e) T2(M).t
                val find_map :
                  'a list ->
                  f:('-> ('b e, 'e) T2(M).t) -> ('b e, 'e) T2(M).t
                val filter :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> ('a list, 'e) T2(M).t
                val filter_map :
                  'a list ->
                  f:('-> ('b e, 'e) T2(M).t) -> ('b list, 'e) T2(M).t
              end
            module Seq :
              sig
                val all :
                  ('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                  ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                val all_ignore :
                  ('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                  (unit, 'e) T2(M).t
                val sequence :
                  (unit, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                  (unit, 'e) T2(M).t
                val map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> ('b, 'e) T2(M).t) ->
                  ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                val iter :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                val fold :
                  'Core_kernel.Std.Sequence.t ->
                  init:'->
                  f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val fold_left :
                  'Core_kernel.Std.Sequence.t ->
                  init:'->
                  f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val fold_right :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> '-> ('b, 'e) T2(M).t) ->
                  init:'-> ('b, 'e) T2(M).t
                val reduce :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> '-> ('a, 'e) T2(M).t) -> ('a e, 'e) T2(M).t
                val exists :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                val for_all :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                val count :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                val find :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) -> ('a e, 'e) T2(M).t
                val find_map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> ('b e, 'e) T2(M).t) -> ('b e, 'e) T2(M).t
                val filter :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) ->
                  ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                val filter_map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> ('b e, 'e) T2(M).t) ->
                  ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
              end
            val ( >=> ) :
              ('-> ('b, 'e) T2(M).t) ->
              ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
            val ( !! ) : '-> ('a, 'e) T2(M).t
            val ( !$ ) : ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
            val ( !$$ ) :
              ('-> '-> 'c) ->
              ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
            val ( !$$$ ) :
              ('-> '-> '-> 'd) ->
              ('a, 'e) T2(M).t ->
              ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
            val ( !$$$$ ) :
              ('-> '-> '-> '-> 'e) ->
              ('a, 's) T2(M).t ->
              ('b, 's) T2(M).t ->
              ('c, 's) T2(M).t -> ('d, 's) T2(M).t -> ('e, 's) T2(M).t
            val ( !$$$$$ ) :
              ('-> '-> '-> '-> '-> 'f) ->
              ('a, 's) T2(M).t ->
              ('b, 's) T2(M).t ->
              ('c, 's) T2(M).t ->
              ('d, 's) T2(M).t -> ('e, 's) T2(M).t -> ('f, 's) T2(M).t
            val ( >>= ) :
              ('a, 'e) T2(M).t ->
              ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
            val ( >>| ) : ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
            module Let_syntax :
              sig
                val return : '-> ('a, 'b) T2(M).t
                val ( >>= ) :
                  ('a, 'e) T2(M).t ->
                  ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val ( >>| ) :
                  ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                module Let_syntax :
                  sig
                    val return : '-> ('a, 'b) T2(M).t
                    val bind :
                      ('a, 'e) T2(M).t ->
                      f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val map :
                      ('a, 'e) T2(M).t -> f:('-> 'b) -> ('b, 'e) T2(M).t
                    val both :
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
                    module Open_on_rhs : sig  end
                  end
              end
            module Monad_infix :
              sig
                val ( >>= ) :
                  ('a, 'e) T2(M).t ->
                  ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val ( >>| ) :
                  ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
              end
            val bind :
              ('a, 'e) T2(M).t ->
              f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
            val return : '-> ('a, 'b) T2(M).t
            val map : ('a, 'e) T2(M).t -> f:('-> 'b) -> ('b, 'e) T2(M).t
            val join : (('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
            val ignore_m : ('a, 'e) T2(M).t -> (unit, 'e) T2(M).t
            val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
            val all_ignore : (unit, 'e) T2(M).t list -> (unit, 'e) T2(M).t
            module Syntax :
              sig
                val ( >>= ) :
                  ('a, 'e) T2(M).t ->
                  ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val ( >>| ) :
                  ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                val ( >=> ) :
                  ('-> ('b, 'e) T2(M).t) ->
                  ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                val ( !! ) : '-> ('a, 'e) T2(M).t
                val ( !$ ) :
                  ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) ->
                  ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  ('a, 'e) T2(M).t ->
                  ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t -> ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t ->
                  ('d, 's) T2(M).t -> ('e, 's) T2(M).t -> ('f, 's) T2(M).t
              end
            val pure : '-> ('a, 'e) T2(M).t
            val accept : '-> ('a, 'e) T2(M).t
            val reject : unit -> ('a, 'e) T2(M).t
            val guard : bool -> (unit, 'e) T2(M).t
            val on : bool -> (unit, 'e) T2(M).t -> (unit, 'e) T2(M).t
            val unless : bool -> (unit, 'e) T2(M).t -> (unit, 'e) T2(M).t
            val zero : unit -> ('a, 'e) T2(M).t
            val plus :
              ('a, 'e) T2(M).t -> ('a, 'e) T2(M).t -> ('a, 'e) T2(M).t
            type 'a error = unit
            val fail : unit -> ('a, 'e) T2(M).t
            val catch :
              ('a, 'e) T2(M).t ->
              (unit -> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
          end
    end
  module Result :
    sig
      type ('a, 'e) result =
        ('a, 'e) Core_kernel.Std.Result.t =
          Ok of 'a
        | Error of 'e
      module type S =
        sig
          type err
          type 'a t
          type 'a m
          type 'a e
          val lift : 'a m -> 'a t
          val run : 'a t -> 'a e
          val void : 'a t -> unit t
          val sequence : unit t list -> unit t
          val forever : 'a t -> 'b t
          module Fn :
            sig
              val id : '-> 'a t
              val ignore : 'a t -> unit t
              val nothing : unit -> unit t
              val non : ('-> bool t) -> '-> bool t
              val apply_n_times : n:int -> ('-> 'a t) -> '-> 'a t
              val compose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
            end
          module Pair :
            sig
              val fst : ('a * 'b) t -> 'a t
              val snd : ('a * 'b) t -> 'b t
            end
          module Triple :
            sig
              val fst : ('a * 'b * 'c) t -> 'a t
              val snd : ('a * 'b * 'c) t -> 'b t
              val trd : ('a * 'b * 'c) t -> 'c t
            end
          module Lift :
            sig
              val nullary : '-> 'a t
              val unary : ('-> 'b) -> 'a t -> 'b t
              val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ternary :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val quaternary :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val quinary :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
            end
          module Exn :
            sig
              val expect :
                ?finally:(unit -> unit t) ->
                f:(unit -> 'a t) -> catch:(exn -> 'a t) -> 'a t
            end
          module Collection :
            sig
              module type S =
                sig
                  type 'a t
                  val all : 'a t t -> 'a t t
                  val all_ignore : 'a t t -> unit t
                  val sequence : unit t t -> unit t
                  val map : 'a t -> f:('-> 'b t) -> 'b t t
                  val iter : 'a t -> f:('-> unit t) -> unit t
                  val fold : 'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce : 'a t -> f:('-> '-> 'a t) -> 'Option.t t
                  val exists : 'a t -> f:('-> bool t) -> bool t
                  val for_all : 'a t -> f:('-> bool t) -> bool t
                  val count : 'a t -> f:('-> bool t) -> int t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b t -> f:('-> 'a t) -> 'a t
                  val find : 'a t -> f:('-> bool t) -> 'Option.t t
                  val find_map :
                    'a t -> f:('-> 'Option.t t) -> 'Option.t t
                  val filter : 'a t -> f:('-> bool t) -> 'a t t
                  val filter_map : 'a t -> f:('-> 'Option.t t) -> 'b t t
                end
              module Eager :
                functor (T : Collection.Eager->
                  sig
                    val all : 'a t T.t -> 'T.t t
                    val all_ignore : 'a t T.t -> unit t
                    val sequence : unit t T.t -> unit t
                    val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                    val iter : 'T.t -> f:('-> unit t) -> unit t
                    val fold :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_left :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_right :
                      'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                    val reduce :
                      'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                    val exists : 'T.t -> f:('-> bool t) -> bool t
                    val for_all : 'T.t -> f:('-> bool t) -> bool t
                    val count : 'T.t -> f:('-> bool t) -> int t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> 'a t) -> 'a t
                    val find : 'T.t -> f:('-> bool t) -> 'Option.t t
                    val find_map :
                      'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                    val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                    val filter_map :
                      'T.t -> f:('-> 'Option.t t) -> 'T.t t
                  end
              module Delay :
                functor (T : Collection.Delay->
                  sig
                    val all : 'a t T.t -> 'T.t t
                    val all_ignore : 'a t T.t -> unit t
                    val sequence : unit t T.t -> unit t
                    val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                    val iter : 'T.t -> f:('-> unit t) -> unit t
                    val fold :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_left :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_right :
                      'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                    val reduce :
                      'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                    val exists : 'T.t -> f:('-> bool t) -> bool t
                    val for_all : 'T.t -> f:('-> bool t) -> bool t
                    val count : 'T.t -> f:('-> bool t) -> int t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> 'a t) -> 'a t
                    val find : 'T.t -> f:('-> bool t) -> 'Option.t t
                    val find_map :
                      'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                    val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                    val filter_map :
                      'T.t -> f:('-> 'Option.t t) -> 'T.t t
                  end
            end
          module List :
            sig
              val all : 'a t list -> 'a list t
              val all_ignore : 'a t list -> unit t
              val sequence : unit t list -> unit t
              val map : 'a list -> f:('-> 'b t) -> 'b list t
              val iter : 'a list -> f:('-> unit t) -> unit t
              val fold : 'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_left :
                'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_right :
                'a list -> f:('-> '-> 'b t) -> init:'-> 'b t
              val reduce : 'a list -> f:('-> '-> 'a t) -> 'Option.t t
              val exists : 'a list -> f:('-> bool t) -> bool t
              val for_all : 'a list -> f:('-> bool t) -> bool t
              val count : 'a list -> f:('-> bool t) -> int t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'b list -> f:('-> 'a t) -> 'a t
              val find : 'a list -> f:('-> bool t) -> 'Option.t t
              val find_map :
                'a list -> f:('-> 'Option.t t) -> 'Option.t t
              val filter : 'a list -> f:('-> bool t) -> 'a list t
              val filter_map :
                'a list -> f:('-> 'Option.t t) -> 'b list t
            end
          module Seq :
            sig
              val all :
                'a t Core_kernel.Std.Sequence.t ->
                'Core_kernel.Std.Sequence.t t
              val all_ignore : 'a t Core_kernel.Std.Sequence.t -> unit t
              val sequence : unit t Core_kernel.Std.Sequence.t -> unit t
              val map :
                'Core_kernel.Std.Sequence.t ->
                f:('-> 'b t) -> 'Core_kernel.Std.Sequence.t t
              val iter :
                'Core_kernel.Std.Sequence.t -> f:('-> unit t) -> unit t
              val fold :
                'Core_kernel.Std.Sequence.t ->
                init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_left :
                'Core_kernel.Std.Sequence.t ->
                init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_right :
                'Core_kernel.Std.Sequence.t ->
                f:('-> '-> 'b t) -> init:'-> 'b t
              val reduce :
                'Core_kernel.Std.Sequence.t ->
                f:('-> '-> 'a t) -> 'Option.t t
              val exists :
                'Core_kernel.Std.Sequence.t -> f:('-> bool t) -> bool t
              val for_all :
                'Core_kernel.Std.Sequence.t -> f:('-> bool t) -> bool t
              val count :
                'Core_kernel.Std.Sequence.t -> f:('-> bool t) -> int t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'Core_kernel.Std.Sequence.t -> f:('-> 'a t) -> 'a t
              val find :
                'Core_kernel.Std.Sequence.t ->
                f:('-> bool t) -> 'Option.t t
              val find_map :
                'Core_kernel.Std.Sequence.t ->
                f:('-> 'Option.t t) -> 'Option.t t
              val filter :
                'Core_kernel.Std.Sequence.t ->
                f:('-> bool t) -> 'Core_kernel.Std.Sequence.t t
              val filter_map :
                'Core_kernel.Std.Sequence.t ->
                f:('-> 'Option.t t) -> 'Core_kernel.Std.Sequence.t t
            end
          val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
          val ( !! ) : '-> 'a t
          val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
          val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
          val ( !$$$ ) :
            ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            'a t -> 'b t -> 'c t -> 'd t -> 'e t
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
          val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
          val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
          module Monad_infix :
            sig
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
            end
          val bind : 'a t -> f:('-> 'b t) -> 'b t
          val return : '-> 'a t
          val map : 'a t -> f:('-> 'b) -> 'b t
          val join : 'a t t -> 'a t
          val ignore_m : 'a t -> unit t
          val all : 'a t list -> 'a list t
          val all_ignore : unit t list -> unit t
          module Let_syntax :
            sig
              val return : '-> 'a t
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              module Let_syntax :
                sig
                  val return : '-> 'a t
                  val bind : 'a t -> f:('-> 'b t) -> 'b t
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val both : 'a t -> 'b t -> ('a * 'b) t
                  module Open_on_rhs : sig  end
                end
            end
          module Syntax :
            sig
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
              val ( !! ) : '-> 'a t
              val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
              val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
            end
          type 'a error = err
          val fail : err -> 'a t
          val catch : 'a t -> (err -> 'a t) -> 'a t
        end
      module type S2 =
        sig
          type ('a, 'e) t
          type 'a m
          type ('a, 'e) e
          val lift : 'a m -> ('a, 'e) t
          val run : ('a, 'e) t -> ('a, 'e) e
          val void : ('a, 'e) t -> (unit, 'e) t
          val sequence : (unit, 'e) t list -> (unit, 'e) t
          val forever : ('a, 'e) t -> ('b, 'e) t
          module Fn :
            sig
              val id : '-> ('a, 'e) t
              val ignore : ('a, 'e) t -> (unit, 'e) t
              val nothing : unit -> (unit, 'e) t
              val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
              val apply_n_times :
                n:int -> ('-> ('a, 'e) t) -> '-> ('a, 'e) t
              val compose :
                ('-> ('c, 'e) t) -> ('-> ('b, 'e) t) -> '-> ('c, 'e) t
            end
          module Pair :
            sig
              val fst : ('a * 'b, 'e) t -> ('a, 'e) t
              val snd : ('a * 'b, 'e) t -> ('b, 'e) t
            end
          module Triple :
            sig
              val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
              val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
              val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
            end
          module Lift :
            sig
              val nullary : '-> ('a, 'e) t
              val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val binary :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ternary :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val quaternary :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val quinary :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
            end
          module Exn :
            sig
              val expect :
                ?finally:(unit -> (unit, 's) t) ->
                f:(unit -> ('a, 's) t) ->
                catch:(exn -> ('a, 's) t) -> ('a, 's) t
            end
          module Collection :
            sig
              module type S =
                sig
                  type 'a t
                  val all : ('a, 'e) t t -> ('a t, 'e) t
                  val all_ignore : ('a, 'e) t t -> (unit, 'e) t
                  val sequence : (unit, 'e) t t -> (unit, 'e) t
                  val map : 'a t -> f:('-> ('b, 'e) t) -> ('b t, 'e) t
                  val iter : 'a t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                  val fold :
                    'a t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'a t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'a t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'a t -> f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                  val exists : 'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count : 'a t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'a t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                  val find_map :
                    'a t ->
                    f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                  val filter : 'a t -> f:('-> (bool, 'e) t) -> ('a t, 'e) t
                  val filter_map :
                    'a t -> f:('-> ('Option.t, 'e) t) -> ('b t, 'e) t
                end
              module Eager :
                functor (T : Collection.Eager->
                  sig
                    val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                    val all_ignore : ('a, 'e) t T.t -> (unit, 'e) t
                    val sequence : (unit, 'e) t T.t -> (unit, 'e) t
                    val map :
                      'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                    val iter :
                      'T.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                    val fold :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_left :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_right :
                      'T.t ->
                      f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                    val reduce :
                      'T.t ->
                      f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                    val exists :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val for_all :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val count :
                      'T.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                    val find :
                      'T.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                    val find_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                    val filter :
                      'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                    val filter_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                  end
              module Delay :
                functor (T : Collection.Delay->
                  sig
                    val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                    val all_ignore : ('a, 'e) t T.t -> (unit, 'e) t
                    val sequence : (unit, 'e) t T.t -> (unit, 'e) t
                    val map :
                      'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                    val iter :
                      'T.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                    val fold :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_left :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_right :
                      'T.t ->
                      f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                    val reduce :
                      'T.t ->
                      f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                    val exists :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val for_all :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val count :
                      'T.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                    val find :
                      'T.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                    val find_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                    val filter :
                      'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                    val filter_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                  end
            end
          module List :
            sig
              val all : ('a, 'e) t list -> ('a list, 'e) t
              val all_ignore : ('a, 'e) t list -> (unit, 'e) t
              val sequence : (unit, 'e) t list -> (unit, 'e) t
              val map : 'a list -> f:('-> ('b, 'e) t) -> ('b list, 'e) t
              val iter : 'a list -> f:('-> (unit, 'e) t) -> (unit, 'e) t
              val fold :
                'a list ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_left :
                'a list ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_right :
                'a list ->
                f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
              val reduce :
                'a list -> f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
              val exists : 'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val for_all : 'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val count : 'a list -> f:('-> (bool, 'e) t) -> (int, 'e) t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'b list -> f:('-> ('a, 'e) t) -> ('a, 'e) t
              val find :
                'a list -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
              val find_map :
                'a list ->
                f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
              val filter :
                'a list -> f:('-> (bool, 'e) t) -> ('a list, 'e) t
              val filter_map :
                'a list -> f:('-> ('Option.t, 'e) t) -> ('b list, 'e) t
            end
          module Seq :
            sig
              val all :
                ('a, 'e) t Core_kernel.Std.Sequence.t ->
                ('Core_kernel.Std.Sequence.t, 'e) t
              val all_ignore :
                ('a, 'e) t Core_kernel.Std.Sequence.t -> (unit, 'e) t
              val sequence :
                (unit, 'e) t Core_kernel.Std.Sequence.t -> (unit, 'e) t
              val map :
                'Core_kernel.Std.Sequence.t ->
                f:('-> ('b, 'e) t) -> ('Core_kernel.Std.Sequence.t, 'e) t
              val iter :
                'Core_kernel.Std.Sequence.t ->
                f:('-> (unit, 'e) t) -> (unit, 'e) t
              val fold :
                'Core_kernel.Std.Sequence.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_left :
                'Core_kernel.Std.Sequence.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_right :
                'Core_kernel.Std.Sequence.t ->
                f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
              val reduce :
                'Core_kernel.Std.Sequence.t ->
                f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
              val exists :
                'Core_kernel.Std.Sequence.t ->
                f:('-> (bool, 'e) t) -> (bool, 'e) t
              val for_all :
                'Core_kernel.Std.Sequence.t ->
                f:('-> (bool, 'e) t) -> (bool, 'e) t
              val count :
                'Core_kernel.Std.Sequence.t ->
                f:('-> (bool, 'e) t) -> (int, 'e) t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'Core_kernel.Std.Sequence.t ->
                f:('-> ('a, 'e) t) -> ('a, 'e) t
              val find :
                'Core_kernel.Std.Sequence.t ->
                f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
              val find_map :
                'Core_kernel.Std.Sequence.t ->
                f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
              val filter :
                'Core_kernel.Std.Sequence.t ->
                f:('-> (bool, 'e) t) ->
                ('Core_kernel.Std.Sequence.t, 'e) t
              val filter_map :
                'Core_kernel.Std.Sequence.t ->
                f:('-> ('Option.t, 'e) t) ->
                ('Core_kernel.Std.Sequence.t, 'e) t
            end
          val ( >=> ) :
            ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
          val ( !! ) : '-> ('a, 'e) t
          val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
          val ( !$$ ) :
            ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
          val ( !$$$ ) :
            ('-> '-> '-> 'd) ->
            ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            ('a, 's) t ->
            ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            ('a, 's) t ->
            ('b, 's) t ->
            ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
          val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
          val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
          module Let_syntax :
            sig
              val return : '-> ('a, 'b) t
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              module Let_syntax :
                sig
                  val return : '-> ('a, 'b) t
                  val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                  val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                  val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                  module Open_on_rhs : sig  end
                end
            end
          module Monad_infix :
            sig
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
            end
          val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
          val return : '-> ('a, 'b) t
          val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
          val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
          val ignore_m : ('a, 'e) t -> (unit, 'e) t
          val all : ('a, 'e) t list -> ('a list, 'e) t
          val all_ignore : (unit, 'e) t list -> (unit, 'e) t
          module Syntax :
            sig
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              val ( >=> ) :
                ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
              val ( !! ) : '-> ('a, 'e) t
              val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val ( !$$ ) :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
            end
          type 'a error = 'a
          val fail : '-> ('a, 'e) t
          val catch : ('a, 'e) t -> ('-> ('a, 'e) t) -> ('a, 'e) t
        end
      module T1 :
        functor (T : Core_kernel.Std.T) (M : Monad->
          sig
            type error = T.t
            type 'a m = 'M.t
            type 'a t =
                ('a, Monads.Std.Monad.Result.T1.error)
                Monads.Std.Monad.Result.result Monads.Std.Monad.Result.T1.m
            type 'a e =
                ('a, Monads.Std.Monad.Result.T1.error)
                Monads.Std.Monad.Result.result Monads.Std.Monad.Result.T1.m
          end
      module T2 :
        functor (M : Monad->
          sig
            type 'a m = 'M.t
            type ('a, 'e) t =
                ('a, 'e) Monads.Std.Monad.Result.result
                Monads.Std.Monad.Result.T2.m
            type ('a, 'e) e =
                ('a, 'e) Monads.Std.Monad.Result.result
                Monads.Std.Monad.Result.T2.m
          end
      module Make :
        functor (T : Core_kernel.Std.T) (M : Monad->
          sig
            val lift : 'M.t -> 'T1(T)(M).t
            val run : 'T1(T)(M).t -> 'T1(T)(M).e
            val void : 'T1(T)(M).t -> unit T1(T)(M).t
            val sequence : unit T1(T)(M).t list -> unit T1(T)(M).t
            val forever : 'T1(T)(M).t -> 'T1(T)(M).t
            module Fn :
              sig
                val id : '-> 'T1(T)(M).t
                val ignore : 'T1(T)(M).t -> unit T1(T)(M).t
                val nothing : unit -> unit T1(T)(M).t
                val non : ('-> bool T1(T)(M).t) -> '-> bool T1(T)(M).t
                val apply_n_times :
                  n:int -> ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                val compose :
                  ('-> 'T1(T)(M).t) ->
                  ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
              end
            module Pair :
              sig
                val fst : ('a * 'b) T1(T)(M).t -> 'T1(T)(M).t
                val snd : ('a * 'b) T1(T)(M).t -> 'T1(T)(M).t
              end
            module Triple :
              sig
                val fst : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                val snd : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                val trd : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
              end
            module Lift :
              sig
                val nullary : '-> 'T1(T)(M).t
                val unary : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                val binary :
                  ('-> '-> 'c) ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ternary :
                  ('-> '-> '-> 'd) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val quaternary :
                  ('-> '-> '-> '-> 'e) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val quinary :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
              end
            module Exn :
              sig
                val expect :
                  ?finally:(unit -> unit T1(T)(M).t) ->
                  f:(unit -> 'T1(T)(M).t) ->
                  catch:(exn -> 'T1(T)(M).t) -> 'T1(T)(M).t
              end
            module Collection :
              sig
                module type S =
                  sig
                    type 'a t
                    val all : 'T1(T)(M).t t -> 'a t T1(T)(M).t
                    val all_ignore : 'T1(T)(M).t t -> unit T1(T)(M).t
                    val sequence : unit T1(T)(M).t t -> unit T1(T)(M).t
                    val map :
                      'a t -> f:('-> 'T1(T)(M).t) -> 'b t T1(T)(M).t
                    val iter :
                      'a t -> f:('-> unit T1(T)(M).t) -> unit T1(T)(M).t
                    val fold :
                      'a t ->
                      init:'->
                      f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val fold_left :
                      'a t ->
                      init:'->
                      f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val fold_right :
                      'a t ->
                      f:('-> '-> 'T1(T)(M).t) ->
                      init:'-> 'T1(T)(M).t
                    val reduce :
                      'a t ->
                      f:('-> '-> 'T1(T)(M).t) -> 'Option.t T1(T)(M).t
                    val exists :
                      'a t -> f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                    val for_all :
                      'a t -> f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                    val count :
                      'a t -> f:('-> bool T1(T)(M).t) -> int T1(T)(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b t -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val find :
                      'a t ->
                      f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                    val find_map :
                      'a t ->
                      f:('-> 'Option.t T1(T)(M).t) ->
                      'Option.t T1(T)(M).t
                    val filter :
                      'a t -> f:('-> bool T1(T)(M).t) -> 'a t T1(T)(M).t
                    val filter_map :
                      'a t ->
                      f:('-> 'Option.t T1(T)(M).t) -> 'b t T1(T)(M).t
                  end
                module Eager :
                  functor (T : Collection.Eager->
                    sig
                      val all : 'T1(T)(M).t T.t -> 'T.t T1(T)(M).t
                      val all_ignore : 'T1(T)(M).t T.t -> unit T1(T)(M).t
                      val sequence : unit T1(T)(M).t T.t -> unit T1(T)(M).t
                      val map :
                        'T.t ->
                        f:('-> 'T1(T)(M).t) -> 'T.t T1(T)(M).t
                      val iter :
                        'T.t ->
                        f:('-> unit T1(T)(M).t) -> unit T1(T)(M).t
                      val fold :
                        'T.t ->
                        init:'->
                        f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                      val fold_left :
                        'T.t ->
                        init:'->
                        f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> 'T1(T)(M).t) ->
                        init:'-> 'T1(T)(M).t
                      val reduce :
                        'T.t ->
                        f:('-> '-> 'T1(T)(M).t) ->
                        'Option.t T1(T)(M).t
                      val exists :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                      val for_all :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                      val count :
                        'T.t -> f:('-> bool T1(T)(M).t) -> int T1(T)(M).t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                      val find :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                      val find_map :
                        'T.t ->
                        f:('-> 'Option.t T1(T)(M).t) ->
                        'Option.t T1(T)(M).t
                      val filter :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> 'T.t T1(T)(M).t
                      val filter_map :
                        'T.t ->
                        f:('-> 'Option.t T1(T)(M).t) -> 'T.t T1(T)(M).t
                    end
                module Delay :
                  functor (T : Collection.Delay->
                    sig
                      val all : 'T1(T)(M).t T.t -> 'T.t T1(T)(M).t
                      val all_ignore : 'T1(T)(M).t T.t -> unit T1(T)(M).t
                      val sequence : unit T1(T)(M).t T.t -> unit T1(T)(M).t
                      val map :
                        'T.t ->
                        f:('-> 'T1(T)(M).t) -> 'T.t T1(T)(M).t
                      val iter :
                        'T.t ->
                        f:('-> unit T1(T)(M).t) -> unit T1(T)(M).t
                      val fold :
                        'T.t ->
                        init:'->
                        f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                      val fold_left :
                        'T.t ->
                        init:'->
                        f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> 'T1(T)(M).t) ->
                        init:'-> 'T1(T)(M).t
                      val reduce :
                        'T.t ->
                        f:('-> '-> 'T1(T)(M).t) ->
                        'Option.t T1(T)(M).t
                      val exists :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                      val for_all :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                      val count :
                        'T.t -> f:('-> bool T1(T)(M).t) -> int T1(T)(M).t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                      val find :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                      val find_map :
                        'T.t ->
                        f:('-> 'Option.t T1(T)(M).t) ->
                        'Option.t T1(T)(M).t
                      val filter :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> 'T.t T1(T)(M).t
                      val filter_map :
                        'T.t ->
                        f:('-> 'Option.t T1(T)(M).t) -> 'T.t T1(T)(M).t
                    end
              end
            module List :
              sig
                val all : 'T1(T)(M).t list -> 'a list T1(T)(M).t
                val all_ignore : 'T1(T)(M).t list -> unit T1(T)(M).t
                val sequence : unit T1(T)(M).t list -> unit T1(T)(M).t
                val map :
                  'a list -> f:('-> 'T1(T)(M).t) -> 'b list T1(T)(M).t
                val iter :
                  'a list -> f:('-> unit T1(T)(M).t) -> unit T1(T)(M).t
                val fold :
                  'a list ->
                  init:'-> f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val fold_left :
                  'a list ->
                  init:'-> f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val fold_right :
                  'a list ->
                  f:('-> '-> 'T1(T)(M).t) -> init:'-> 'T1(T)(M).t
                val reduce :
                  'a list ->
                  f:('-> '-> 'T1(T)(M).t) -> 'Option.t T1(T)(M).t
                val exists :
                  'a list -> f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                val for_all :
                  'a list -> f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                val count :
                  'a list -> f:('-> bool T1(T)(M).t) -> int T1(T)(M).t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'b list -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val find :
                  'a list ->
                  f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                val find_map :
                  'a list ->
                  f:('-> 'Option.t T1(T)(M).t) -> 'Option.t T1(T)(M).t
                val filter :
                  'a list -> f:('-> bool T1(T)(M).t) -> 'a list T1(T)(M).t
                val filter_map :
                  'a list ->
                  f:('-> 'Option.t T1(T)(M).t) -> 'b list T1(T)(M).t
              end
            module Seq :
              sig
                val all :
                  'T1(T)(M).t Core_kernel.Std.Sequence.t ->
                  'Core_kernel.Std.Sequence.t T1(T)(M).t
                val all_ignore :
                  'T1(T)(M).t Core_kernel.Std.Sequence.t -> unit T1(T)(M).t
                val sequence :
                  unit T1(T)(M).t Core_kernel.Std.Sequence.t ->
                  unit T1(T)(M).t
                val map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> 'T1(T)(M).t) ->
                  'Core_kernel.Std.Sequence.t T1(T)(M).t
                val iter :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> unit T1(T)(M).t) -> unit T1(T)(M).t
                val fold :
                  'Core_kernel.Std.Sequence.t ->
                  init:'-> f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val fold_left :
                  'Core_kernel.Std.Sequence.t ->
                  init:'-> f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val fold_right :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> '-> 'T1(T)(M).t) -> init:'-> 'T1(T)(M).t
                val reduce :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> '-> 'T1(T)(M).t) -> 'Option.t T1(T)(M).t
                val exists :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                val for_all :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                val count :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(T)(M).t) -> int T1(T)(M).t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val find :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                val find_map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> 'Option.t T1(T)(M).t) -> 'Option.t T1(T)(M).t
                val filter :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(T)(M).t) ->
                  'Core_kernel.Std.Sequence.t T1(T)(M).t
                val filter_map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> 'Option.t T1(T)(M).t) ->
                  'Core_kernel.Std.Sequence.t T1(T)(M).t
              end
            val ( >=> ) :
              ('-> 'T1(T)(M).t) ->
              ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
            val ( !! ) : '-> 'T1(T)(M).t
            val ( !$ ) : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
            val ( !$$ ) :
              ('-> '-> 'c) ->
              'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
            val ( !$$$ ) :
              ('-> '-> '-> 'd) ->
              'T1(T)(M).t ->
              'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
            val ( !$$$$ ) :
              ('-> '-> '-> '-> 'e) ->
              'T1(T)(M).t ->
              'T1(T)(M).t ->
              'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
            val ( !$$$$$ ) :
              ('-> '-> '-> '-> '-> 'f) ->
              'T1(T)(M).t ->
              'T1(T)(M).t ->
              'T1(T)(M).t ->
              'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
            val ( >>= ) :
              'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
            val ( >>| ) : 'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
            module Monad_infix :
              sig
                val ( >>= ) :
                  'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val ( >>| ) : 'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
              end
            val bind :
              'T1(T)(M).t -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
            val return : '-> 'T1(T)(M).t
            val map : 'T1(T)(M).t -> f:('-> 'b) -> 'T1(T)(M).t
            val join : 'T1(T)(M).t T1(T)(M).t -> 'T1(T)(M).t
            val ignore_m : 'T1(T)(M).t -> unit T1(T)(M).t
            val all : 'T1(T)(M).t list -> 'a list T1(T)(M).t
            val all_ignore : unit T1(T)(M).t list -> unit T1(T)(M).t
            module Let_syntax :
              sig
                val return : '-> 'T1(T)(M).t
                val ( >>= ) :
                  'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val ( >>| ) : 'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                module Let_syntax :
                  sig
                    val return : '-> 'T1(T)(M).t
                    val bind :
                      'T1(T)(M).t ->
                      f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val map : 'T1(T)(M).t -> f:('-> 'b) -> 'T1(T)(M).t
                    val both :
                      'T1(T)(M).t -> 'T1(T)(M).t -> ('a * 'b) T1(T)(M).t
                    module Open_on_rhs : sig  end
                  end
              end
            module Syntax :
              sig
                val ( >>= ) :
                  'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val ( >>| ) : 'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                val ( >=> ) :
                  ('-> 'T1(T)(M).t) ->
                  ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                val ( !! ) : '-> 'T1(T)(M).t
                val ( !$ ) : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
              end
            type 'a error = T.t
            val fail : T.t -> 'T1(T)(M).t
            val catch :
              'T1(T)(M).t -> (T.t -> 'T1(T)(M).t) -> 'T1(T)(M).t
          end
      module Make2 :
        functor (M : Monad->
          sig
            val lift : 'M.t -> ('a, 'e) T2(M).t
            val run : ('a, 'e) T2(M).t -> ('a, 'e) T2(M).e
            val void : ('a, 'e) T2(M).t -> (unit, 'e) T2(M).t
            val sequence : (unit, 'e) T2(M).t list -> (unit, 'e) T2(M).t
            val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
            module Fn :
              sig
                val id : '-> ('a, 'e) T2(M).t
                val ignore : ('a, 'e) T2(M).t -> (unit, 'e) T2(M).t
                val nothing : unit -> (unit, 'e) T2(M).t
                val non :
                  ('-> (bool, 'e) T2(M).t) -> '-> (bool, 'e) T2(M).t
                val apply_n_times :
                  n:int -> ('-> ('a, 'e) T2(M).t) -> '-> ('a, 'e) T2(M).t
                val compose :
                  ('-> ('c, 'e) T2(M).t) ->
                  ('-> ('b, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
              end
            module Pair :
              sig
                val fst : ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
                val snd : ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
              end
            module Triple :
              sig
                val fst : ('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
                val snd : ('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
                val trd : ('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
              end
            module Lift :
              sig
                val nullary : '-> ('a, 'e) T2(M).t
                val unary :
                  ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                val binary :
                  ('-> '-> 'c) ->
                  ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                val ternary :
                  ('-> '-> '-> 'd) ->
                  ('a, 'e) T2(M).t ->
                  ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                val quaternary :
                  ('-> '-> '-> '-> 'e) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t -> ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                val quinary :
                  ('-> '-> '-> '-> '-> 'f) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t ->
                  ('d, 's) T2(M).t -> ('e, 's) T2(M).t -> ('f, 's) T2(M).t
              end
            module Exn :
              sig
                val expect :
                  ?finally:(unit -> (unit, 's) T2(M).t) ->
                  f:(unit -> ('a, 's) T2(M).t) ->
                  catch:(exn -> ('a, 's) T2(M).t) -> ('a, 's) T2(M).t
              end
            module Collection :
              sig
                module type S =
                  sig
                    type 'a t
                    val all : ('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
                    val all_ignore : ('a, 'e) T2(M).t t -> (unit, 'e) T2(M).t
                    val sequence : (unit, 'e) T2(M).t t -> (unit, 'e) T2(M).t
                    val map :
                      'a t ->
                      f:('-> ('b, 'e) T2(M).t) -> ('b t, 'e) T2(M).t
                    val iter :
                      'a t ->
                      f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                    val fold :
                      'a t ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_left :
                      'a t ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_right :
                      'a t ->
                      f:('-> '-> ('b, 'e) T2(M).t) ->
                      init:'-> ('b, 'e) T2(M).t
                    val reduce :
                      'a t ->
                      f:('-> '-> ('a, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val exists :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val for_all :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val count :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b t -> f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                    val find :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val find_map :
                      'a t ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val filter :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) -> ('a t, 'e) T2(M).t
                    val filter_map :
                      'a t ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('b t, 'e) T2(M).t
                  end
                module Eager :
                  functor (T : Collection.Eager->
                    sig
                      val all : ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                      val all_ignore :
                        ('a, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                      val sequence :
                        (unit, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                      val map :
                        'T.t ->
                        f:('-> ('b, 'e) T2(M).t) -> ('T.t, 'e) T2(M).t
                      val iter :
                        'T.t ->
                        f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                      val fold :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                      val fold_left :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> ('b, 'e) T2(M).t) ->
                        init:'-> ('b, 'e) T2(M).t
                      val reduce :
                        'T.t ->
                        f:('-> '-> ('a, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val exists :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                      val for_all :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                      val count :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t ->
                        f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                      val find :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val find_map :
                        'T.t ->
                        f:('-> ('Option.t, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val filter :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> ('T.t, 'e) T2(M).t
                      val filter_map :
                        'T.t ->
                        f:('-> ('Option.t, 'e) T2(M).t) ->
                        ('T.t, 'e) T2(M).t
                    end
                module Delay :
                  functor (T : Collection.Delay->
                    sig
                      val all : ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                      val all_ignore :
                        ('a, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                      val sequence :
                        (unit, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                      val map :
                        'T.t ->
                        f:('-> ('b, 'e) T2(M).t) -> ('T.t, 'e) T2(M).t
                      val iter :
                        'T.t ->
                        f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                      val fold :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                      val fold_left :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> ('b, 'e) T2(M).t) ->
                        init:'-> ('b, 'e) T2(M).t
                      val reduce :
                        'T.t ->
                        f:('-> '-> ('a, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val exists :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                      val for_all :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                      val count :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t ->
                        f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                      val find :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val find_map :
                        'T.t ->
                        f:('-> ('Option.t, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val filter :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> ('T.t, 'e) T2(M).t
                      val filter_map :
                        'T.t ->
                        f:('-> ('Option.t, 'e) T2(M).t) ->
                        ('T.t, 'e) T2(M).t
                    end
              end
            module List :
              sig
                val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                val all_ignore : ('a, 'e) T2(M).t list -> (unit, 'e) T2(M).t
                val sequence : (unit, 'e) T2(M).t list -> (unit, 'e) T2(M).t
                val map :
                  'a list ->
                  f:('-> ('b, 'e) T2(M).t) -> ('b list, 'e) T2(M).t
                val iter :
                  'a list ->
                  f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                val fold :
                  'a list ->
                  init:'->
                  f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val fold_left :
                  'a list ->
                  init:'->
                  f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val fold_right :
                  'a list ->
                  f:('-> '-> ('b, 'e) T2(M).t) ->
                  init:'-> ('b, 'e) T2(M).t
                val reduce :
                  'a list ->
                  f:('-> '-> ('a, 'e) T2(M).t) ->
                  ('Option.t, 'e) T2(M).t
                val exists :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                val for_all :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                val count :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'b list -> f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                val find :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> ('Option.t, 'e) T2(M).t
                val find_map :
                  'a list ->
                  f:('-> ('Option.t, 'e) T2(M).t) ->
                  ('Option.t, 'e) T2(M).t
                val filter :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> ('a list, 'e) T2(M).t
                val filter_map :
                  'a list ->
                  f:('-> ('Option.t, 'e) T2(M).t) ->
                  ('b list, 'e) T2(M).t
              end
            module Seq :
              sig
                val all :
                  ('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                  ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                val all_ignore :
                  ('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                  (unit, 'e) T2(M).t
                val sequence :
                  (unit, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                  (unit, 'e) T2(M).t
                val map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> ('b, 'e) T2(M).t) ->
                  ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                val iter :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                val fold :
                  'Core_kernel.Std.Sequence.t ->
                  init:'->
                  f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val fold_left :
                  'Core_kernel.Std.Sequence.t ->
                  init:'->
                  f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val fold_right :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> '-> ('b, 'e) T2(M).t) ->
                  init:'-> ('b, 'e) T2(M).t
                val reduce :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> '-> ('a, 'e) T2(M).t) ->
                  ('Option.t, 'e) T2(M).t
                val exists :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                val for_all :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                val count :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                val find :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) -> ('Option.t, 'e) T2(M).t
                val find_map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> ('Option.t, 'e) T2(M).t) ->
                  ('Option.t, 'e) T2(M).t
                val filter :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) ->
                  ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                val filter_map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> ('Option.t, 'e) T2(M).t) ->
                  ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
              end
            val ( >=> ) :
              ('-> ('b, 'e) T2(M).t) ->
              ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
            val ( !! ) : '-> ('a, 'e) T2(M).t
            val ( !$ ) : ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
            val ( !$$ ) :
              ('-> '-> 'c) ->
              ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
            val ( !$$$ ) :
              ('-> '-> '-> 'd) ->
              ('a, 'e) T2(M).t ->
              ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
            val ( !$$$$ ) :
              ('-> '-> '-> '-> 'e) ->
              ('a, 's) T2(M).t ->
              ('b, 's) T2(M).t ->
              ('c, 's) T2(M).t -> ('d, 's) T2(M).t -> ('e, 's) T2(M).t
            val ( !$$$$$ ) :
              ('-> '-> '-> '-> '-> 'f) ->
              ('a, 's) T2(M).t ->
              ('b, 's) T2(M).t ->
              ('c, 's) T2(M).t ->
              ('d, 's) T2(M).t -> ('e, 's) T2(M).t -> ('f, 's) T2(M).t
            val ( >>= ) :
              ('a, 'e) T2(M).t ->
              ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
            val ( >>| ) : ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
            module Let_syntax :
              sig
                val return : '-> ('a, 'b) T2(M).t
                val ( >>= ) :
                  ('a, 'e) T2(M).t ->
                  ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val ( >>| ) :
                  ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                module Let_syntax :
                  sig
                    val return : '-> ('a, 'b) T2(M).t
                    val bind :
                      ('a, 'e) T2(M).t ->
                      f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val map :
                      ('a, 'e) T2(M).t -> f:('-> 'b) -> ('b, 'e) T2(M).t
                    val both :
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
                    module Open_on_rhs : sig  end
                  end
              end
            module Monad_infix :
              sig
                val ( >>= ) :
                  ('a, 'e) T2(M).t ->
                  ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val ( >>| ) :
                  ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
              end
            val bind :
              ('a, 'e) T2(M).t ->
              f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
            val return : '-> ('a, 'b) T2(M).t
            val map : ('a, 'e) T2(M).t -> f:('-> 'b) -> ('b, 'e) T2(M).t
            val join : (('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
            val ignore_m : ('a, 'e) T2(M).t -> (unit, 'e) T2(M).t
            val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
            val all_ignore : (unit, 'e) T2(M).t list -> (unit, 'e) T2(M).t
            module Syntax :
              sig
                val ( >>= ) :
                  ('a, 'e) T2(M).t ->
                  ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val ( >>| ) :
                  ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                val ( >=> ) :
                  ('-> ('b, 'e) T2(M).t) ->
                  ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                val ( !! ) : '-> ('a, 'e) T2(M).t
                val ( !$ ) :
                  ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) ->
                  ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  ('a, 'e) T2(M).t ->
                  ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t -> ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t ->
                  ('d, 's) T2(M).t -> ('e, 's) T2(M).t -> ('f, 's) T2(M).t
              end
            type 'a error = 'a
            val fail : '-> ('a, 'e) T2(M).t
            val catch :
              ('a, 'e) T2(M).t ->
              ('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
          end
      module Error :
        sig
          module type S =
            sig
              type err
              type 'a t
              type 'a m
              type 'a e
              val lift : 'a m -> 'a t
              val run : 'a t -> 'a e
              val void : 'a t -> unit t
              val sequence : unit t list -> unit t
              val forever : 'a t -> 'b t
              module Fn :
                sig
                  val id : '-> 'a t
                  val ignore : 'a t -> unit t
                  val nothing : unit -> unit t
                  val non : ('-> bool t) -> '-> bool t
                  val apply_n_times : n:int -> ('-> 'a t) -> '-> 'a t
                  val compose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
                end
              module Pair :
                sig
                  val fst : ('a * 'b) t -> 'a t
                  val snd : ('a * 'b) t -> 'b t
                end
              module Triple :
                sig
                  val fst : ('a * 'b * 'c) t -> 'a t
                  val snd : ('a * 'b * 'c) t -> 'b t
                  val trd : ('a * 'b * 'c) t -> 'c t
                end
              module Lift :
                sig
                  val nullary : '-> 'a t
                  val unary : ('-> 'b) -> 'a t -> 'b t
                  val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ternary :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val quaternary :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val quinary :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                end
              module Exn :
                sig
                  val expect :
                    ?finally:(unit -> unit t) ->
                    f:(unit -> 'a t) -> catch:(exn -> 'a t) -> 'a t
                end
              module Collection :
                sig
                  module type S =
                    sig
                      type 'a t
                      val all : 'a t t -> 'a t t
                      val all_ignore : 'a t t -> unit t
                      val sequence : unit t t -> unit t
                      val map : 'a t -> f:('-> 'b t) -> 'b t t
                      val iter : 'a t -> f:('-> unit t) -> unit t
                      val fold :
                        'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'a t -> f:('-> '-> 'a t) -> 'Option.t t
                      val exists : 'a t -> f:('-> bool t) -> bool t
                      val for_all : 'a t -> f:('-> bool t) -> bool t
                      val count : 'a t -> f:('-> bool t) -> int t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b t -> f:('-> 'a t) -> 'a t
                      val find : 'a t -> f:('-> bool t) -> 'Option.t t
                      val find_map :
                        'a t -> f:('-> 'Option.t t) -> 'Option.t t
                      val filter : 'a t -> f:('-> bool t) -> 'a t t
                      val filter_map :
                        'a t -> f:('-> 'Option.t t) -> 'b t t
                    end
                  module Eager :
                    functor (T : Collection.Eager->
                      sig
                        val all : 'a t T.t -> 'T.t t
                        val all_ignore : 'a t T.t -> unit t
                        val sequence : unit t T.t -> unit t
                        val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                        val iter : 'T.t -> f:('-> unit t) -> unit t
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_right :
                          'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                        val reduce :
                          'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                        val exists : 'T.t -> f:('-> bool t) -> bool t
                        val for_all : 'T.t -> f:('-> bool t) -> bool t
                        val count : 'T.t -> f:('-> bool t) -> int t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a t) -> 'a t
                        val find :
                          'T.t -> f:('-> bool t) -> 'Option.t t
                        val find_map :
                          'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                        val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                        val filter_map :
                          'T.t -> f:('-> 'Option.t t) -> 'T.t t
                      end
                  module Delay :
                    functor (T : Collection.Delay->
                      sig
                        val all : 'a t T.t -> 'T.t t
                        val all_ignore : 'a t T.t -> unit t
                        val sequence : unit t T.t -> unit t
                        val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                        val iter : 'T.t -> f:('-> unit t) -> unit t
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_right :
                          'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                        val reduce :
                          'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                        val exists : 'T.t -> f:('-> bool t) -> bool t
                        val for_all : 'T.t -> f:('-> bool t) -> bool t
                        val count : 'T.t -> f:('-> bool t) -> int t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a t) -> 'a t
                        val find :
                          'T.t -> f:('-> bool t) -> 'Option.t t
                        val find_map :
                          'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                        val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                        val filter_map :
                          'T.t -> f:('-> 'Option.t t) -> 'T.t t
                      end
                end
              module List :
                sig
                  val all : 'a t list -> 'a list t
                  val all_ignore : 'a t list -> unit t
                  val sequence : unit t list -> unit t
                  val map : 'a list -> f:('-> 'b t) -> 'b list t
                  val iter : 'a list -> f:('-> unit t) -> unit t
                  val fold :
                    'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'a list -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce :
                    'a list -> f:('-> '-> 'a t) -> 'Option.t t
                  val exists : 'a list -> f:('-> bool t) -> bool t
                  val for_all : 'a list -> f:('-> bool t) -> bool t
                  val count : 'a list -> f:('-> bool t) -> int t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b list -> f:('-> 'a t) -> 'a t
                  val find : 'a list -> f:('-> bool t) -> 'Option.t t
                  val find_map :
                    'a list -> f:('-> 'Option.t t) -> 'Option.t t
                  val filter : 'a list -> f:('-> bool t) -> 'a list t
                  val filter_map :
                    'a list -> f:('-> 'Option.t t) -> 'b list t
                end
              module Seq :
                sig
                  val all :
                    'a t Core_kernel.Std.Sequence.t ->
                    'Core_kernel.Std.Sequence.t t
                  val all_ignore : 'a t Core_kernel.Std.Sequence.t -> unit t
                  val sequence : unit t Core_kernel.Std.Sequence.t -> unit t
                  val map :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> 'b t) -> 'Core_kernel.Std.Sequence.t t
                  val iter :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> unit t) -> unit t
                  val fold :
                    'Core_kernel.Std.Sequence.t ->
                    init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'Core_kernel.Std.Sequence.t ->
                    init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> '-> 'a t) -> 'Option.t t
                  val exists :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> bool t) -> bool t
                  val for_all :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> bool t) -> bool t
                  val count :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> bool t) -> int t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'Core_kernel.Std.Sequence.t -> f:('-> 'a t) -> 'a t
                  val find :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> bool t) -> 'Option.t t
                  val find_map :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> 'Option.t t) -> 'Option.t t
                  val filter :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> bool t) -> 'Core_kernel.Std.Sequence.t t
                  val filter_map :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> 'Option.t t) ->
                    'Core_kernel.Std.Sequence.t t
                end
              val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
              val ( !! ) : '-> 'a t
              val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
              val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              module Monad_infix :
                sig
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                end
              val bind : 'a t -> f:('-> 'b t) -> 'b t
              val return : '-> 'a t
              val map : 'a t -> f:('-> 'b) -> 'b t
              val join : 'a t t -> 'a t
              val ignore_m : 'a t -> unit t
              val all : 'a t list -> 'a list t
              val all_ignore : unit t list -> unit t
              module Let_syntax :
                sig
                  val return : '-> 'a t
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  module Let_syntax :
                    sig
                      val return : '-> 'a t
                      val bind : 'a t -> f:('-> 'b t) -> 'b t
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val both : 'a t -> 'b t -> ('a * 'b) t
                      module Open_on_rhs : sig  end
                    end
                end
              module Syntax :
                sig
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                  val ( !! ) : '-> 'a t
                  val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                  val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                end
              type 'a error = err
              val fail : err -> 'a t
              val catch : 'a t -> (err -> 'a t) -> 'a t
              val failf :
                ('a, Format.formatter, unit, unit -> 'b t)
                Core_kernel.Std.format4 -> 'a
            end
          module T :
            functor (M : Monad->
              sig
                type 'a m = 'M.t
                type 'a t =
                    'Core_kernel.Std.Or_error.t
                    Monads.Std.Monad.Result.Error.T.m
                type 'a e =
                    'Core_kernel.Std.Or_error.t
                    Monads.Std.Monad.Result.Error.T.m
              end
          module Make :
            functor (M : Monad->
              sig
                val lift : 'M.t -> 'T(M).t
                val run : 'T(M).t -> 'T(M).e
                val void : 'T(M).t -> unit T(M).t
                val sequence : unit T(M).t list -> unit T(M).t
                val forever : 'T(M).t -> 'T(M).t
                module Fn :
                  sig
                    val id : '-> 'T(M).t
                    val ignore : 'T(M).t -> unit T(M).t
                    val nothing : unit -> unit T(M).t
                    val non : ('-> bool T(M).t) -> '-> bool T(M).t
                    val apply_n_times :
                      n:int -> ('-> 'T(M).t) -> '-> 'T(M).t
                    val compose :
                      ('-> 'T(M).t) ->
                      ('-> 'T(M).t) -> '-> 'T(M).t
                  end
                module Pair :
                  sig
                    val fst : ('a * 'b) T(M).t -> 'T(M).t
                    val snd : ('a * 'b) T(M).t -> 'T(M).t
                  end
                module Triple :
                  sig
                    val fst : ('a * 'b * 'c) T(M).t -> 'T(M).t
                    val snd : ('a * 'b * 'c) T(M).t -> 'T(M).t
                    val trd : ('a * 'b * 'c) T(M).t -> 'T(M).t
                  end
                module Lift :
                  sig
                    val nullary : '-> 'T(M).t
                    val unary : ('-> 'b) -> 'T(M).t -> 'T(M).t
                    val binary :
                      ('-> '-> 'c) -> 'T(M).t -> 'T(M).t -> 'T(M).t
                    val ternary :
                      ('-> '-> '-> 'd) ->
                      'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                    val quaternary :
                      ('-> '-> '-> '-> 'e) ->
                      'T(M).t ->
                      'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                    val quinary :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T(M).t ->
                      'T(M).t ->
                      'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                  end
                module Exn :
                  sig
                    val expect :
                      ?finally:(unit -> unit T(M).t) ->
                      f:(unit -> 'T(M).t) ->
                      catch:(exn -> 'T(M).t) -> 'T(M).t
                  end
                module Collection :
                  sig
                    module type S =
                      sig
                        type 'a t
                        val all : 'T(M).t t -> 'a t T(M).t
                        val all_ignore : 'T(M).t t -> unit T(M).t
                        val sequence : unit T(M).t t -> unit T(M).t
                        val map : 'a t -> f:('-> 'T(M).t) -> 'b t T(M).t
                        val iter :
                          'a t -> f:('-> unit T(M).t) -> unit T(M).t
                        val fold :
                          'a t ->
                          init:'-> f:('-> '-> 'T(M).t) -> 'T(M).t
                        val fold_left :
                          'a t ->
                          init:'-> f:('-> '-> 'T(M).t) -> 'T(M).t
                        val fold_right :
                          'a t ->
                          f:('-> '-> 'T(M).t) -> init:'-> 'T(M).t
                        val reduce :
                          'a t ->
                          f:('-> '-> 'T(M).t) -> 'Option.t T(M).t
                        val exists :
                          'a t -> f:('-> bool T(M).t) -> bool T(M).t
                        val for_all :
                          'a t -> f:('-> bool T(M).t) -> bool T(M).t
                        val count :
                          'a t -> f:('-> bool T(M).t) -> int T(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b t -> f:('-> 'T(M).t) -> 'T(M).t
                        val find :
                          'a t -> f:('-> bool T(M).t) -> 'Option.t T(M).t
                        val find_map :
                          'a t ->
                          f:('-> 'Option.t T(M).t) -> 'Option.t T(M).t
                        val filter :
                          'a t -> f:('-> bool T(M).t) -> 'a t T(M).t
                        val filter_map :
                          'a t -> f:('-> 'Option.t T(M).t) -> 'b t T(M).t
                      end
                    module Eager :
                      functor (T : Collection.Eager->
                        sig
                          val all : 'T(M).t T.t -> 'T.t T(M).t
                          val all_ignore : 'T(M).t T.t -> unit T(M).t
                          val sequence : unit T(M).t T.t -> unit T(M).t
                          val map :
                            'T.t -> f:('-> 'T(M).t) -> 'T.t T(M).t
                          val iter :
                            'T.t -> f:('-> unit T(M).t) -> unit T(M).t
                          val fold :
                            'T.t ->
                            init:'-> f:('-> '-> 'T(M).t) -> 'T(M).t
                          val fold_left :
                            'T.t ->
                            init:'-> f:('-> '-> 'T(M).t) -> 'T(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> 'T(M).t) -> init:'-> 'T(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> 'T(M).t) -> 'Option.t T(M).t
                          val exists :
                            'T.t -> f:('-> bool T(M).t) -> bool T(M).t
                          val for_all :
                            'T.t -> f:('-> bool T(M).t) -> bool T(M).t
                          val count :
                            'T.t -> f:('-> bool T(M).t) -> int T(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t -> f:('-> 'T(M).t) -> 'T(M).t
                          val find :
                            'T.t ->
                            f:('-> bool T(M).t) -> 'Option.t T(M).t
                          val find_map :
                            'T.t ->
                            f:('-> 'Option.t T(M).t) ->
                            'Option.t T(M).t
                          val filter :
                            'T.t -> f:('-> bool T(M).t) -> 'T.t T(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> 'Option.t T(M).t) -> 'T.t T(M).t
                        end
                    module Delay :
                      functor (T : Collection.Delay->
                        sig
                          val all : 'T(M).t T.t -> 'T.t T(M).t
                          val all_ignore : 'T(M).t T.t -> unit T(M).t
                          val sequence : unit T(M).t T.t -> unit T(M).t
                          val map :
                            'T.t -> f:('-> 'T(M).t) -> 'T.t T(M).t
                          val iter :
                            'T.t -> f:('-> unit T(M).t) -> unit T(M).t
                          val fold :
                            'T.t ->
                            init:'-> f:('-> '-> 'T(M).t) -> 'T(M).t
                          val fold_left :
                            'T.t ->
                            init:'-> f:('-> '-> 'T(M).t) -> 'T(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> 'T(M).t) -> init:'-> 'T(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> 'T(M).t) -> 'Option.t T(M).t
                          val exists :
                            'T.t -> f:('-> bool T(M).t) -> bool T(M).t
                          val for_all :
                            'T.t -> f:('-> bool T(M).t) -> bool T(M).t
                          val count :
                            'T.t -> f:('-> bool T(M).t) -> int T(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t -> f:('-> 'T(M).t) -> 'T(M).t
                          val find :
                            'T.t ->
                            f:('-> bool T(M).t) -> 'Option.t T(M).t
                          val find_map :
                            'T.t ->
                            f:('-> 'Option.t T(M).t) ->
                            'Option.t T(M).t
                          val filter :
                            'T.t -> f:('-> bool T(M).t) -> 'T.t T(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> 'Option.t T(M).t) -> 'T.t T(M).t
                        end
                  end
                module List :
                  sig
                    val all : 'T(M).t list -> 'a list T(M).t
                    val all_ignore : 'T(M).t list -> unit T(M).t
                    val sequence : unit T(M).t list -> unit T(M).t
                    val map :
                      'a list -> f:('-> 'T(M).t) -> 'b list T(M).t
                    val iter :
                      'a list -> f:('-> unit T(M).t) -> unit T(M).t
                    val fold :
                      'a list ->
                      init:'-> f:('-> '-> 'T(M).t) -> 'T(M).t
                    val fold_left :
                      'a list ->
                      init:'-> f:('-> '-> 'T(M).t) -> 'T(M).t
                    val fold_right :
                      'a list ->
                      f:('-> '-> 'T(M).t) -> init:'-> 'T(M).t
                    val reduce :
                      'a list ->
                      f:('-> '-> 'T(M).t) -> 'Option.t T(M).t
                    val exists :
                      'a list -> f:('-> bool T(M).t) -> bool T(M).t
                    val for_all :
                      'a list -> f:('-> bool T(M).t) -> bool T(M).t
                    val count :
                      'a list -> f:('-> bool T(M).t) -> int T(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b list -> f:('-> 'T(M).t) -> 'T(M).t
                    val find :
                      'a list -> f:('-> bool T(M).t) -> 'Option.t T(M).t
                    val find_map :
                      'a list ->
                      f:('-> 'Option.t T(M).t) -> 'Option.t T(M).t
                    val filter :
                      'a list -> f:('-> bool T(M).t) -> 'a list T(M).t
                    val filter_map :
                      'a list ->
                      f:('-> 'Option.t T(M).t) -> 'b list T(M).t
                  end
                module Seq :
                  sig
                    val all :
                      'T(M).t Core_kernel.Std.Sequence.t ->
                      'Core_kernel.Std.Sequence.t T(M).t
                    val all_ignore :
                      'T(M).t Core_kernel.Std.Sequence.t -> unit T(M).t
                    val sequence :
                      unit T(M).t Core_kernel.Std.Sequence.t -> unit T(M).t
                    val map :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> 'T(M).t) ->
                      'Core_kernel.Std.Sequence.t T(M).t
                    val iter :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> unit T(M).t) -> unit T(M).t
                    val fold :
                      'Core_kernel.Std.Sequence.t ->
                      init:'-> f:('-> '-> 'T(M).t) -> 'T(M).t
                    val fold_left :
                      'Core_kernel.Std.Sequence.t ->
                      init:'-> f:('-> '-> 'T(M).t) -> 'T(M).t
                    val fold_right :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> '-> 'T(M).t) -> init:'-> 'T(M).t
                    val reduce :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> '-> 'T(M).t) -> 'Option.t T(M).t
                    val exists :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> bool T(M).t) -> bool T(M).t
                    val for_all :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> bool T(M).t) -> bool T(M).t
                    val count :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> bool T(M).t) -> int T(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> 'T(M).t) -> 'T(M).t
                    val find :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> bool T(M).t) -> 'Option.t T(M).t
                    val find_map :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> 'Option.t T(M).t) -> 'Option.t T(M).t
                    val filter :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> bool T(M).t) ->
                      'Core_kernel.Std.Sequence.t T(M).t
                    val filter_map :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> 'Option.t T(M).t) ->
                      'Core_kernel.Std.Sequence.t T(M).t
                  end
                val ( >=> ) :
                  ('-> 'T(M).t) -> ('-> 'T(M).t) -> '-> 'T(M).t
                val ( !! ) : '-> 'T(M).t
                val ( !$ ) : ('-> 'b) -> 'T(M).t -> 'T(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) -> 'T(M).t -> 'T(M).t -> 'T(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  'T(M).t ->
                  'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'T(M).t ->
                  'T(M).t ->
                  'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                val ( >>= ) : 'T(M).t -> ('-> 'T(M).t) -> 'T(M).t
                val ( >>| ) : 'T(M).t -> ('-> 'b) -> 'T(M).t
                module Monad_infix :
                  sig
                    val ( >>= ) : 'T(M).t -> ('-> 'T(M).t) -> 'T(M).t
                    val ( >>| ) : 'T(M).t -> ('-> 'b) -> 'T(M).t
                  end
                val bind : 'T(M).t -> f:('-> 'T(M).t) -> 'T(M).t
                val return : '-> 'T(M).t
                val map : 'T(M).t -> f:('-> 'b) -> 'T(M).t
                val join : 'T(M).t T(M).t -> 'T(M).t
                val ignore_m : 'T(M).t -> unit T(M).t
                val all : 'T(M).t list -> 'a list T(M).t
                val all_ignore : unit T(M).t list -> unit T(M).t
                module Let_syntax :
                  sig
                    val return : '-> 'T(M).t
                    val ( >>= ) : 'T(M).t -> ('-> 'T(M).t) -> 'T(M).t
                    val ( >>| ) : 'T(M).t -> ('-> 'b) -> 'T(M).t
                    module Let_syntax :
                      sig
                        val return : '-> 'T(M).t
                        val bind :
                          'T(M).t -> f:('-> 'T(M).t) -> 'T(M).t
                        val map : 'T(M).t -> f:('-> 'b) -> 'T(M).t
                        val both : 'T(M).t -> 'T(M).t -> ('a * 'b) T(M).t
                        module Open_on_rhs : sig  end
                      end
                  end
                module Syntax :
                  sig
                    val ( >>= ) : 'T(M).t -> ('-> 'T(M).t) -> 'T(M).t
                    val ( >>| ) : 'T(M).t -> ('-> 'b) -> 'T(M).t
                    val ( >=> ) :
                      ('-> 'T(M).t) ->
                      ('-> 'T(M).t) -> '-> 'T(M).t
                    val ( !! ) : '-> 'T(M).t
                    val ( !$ ) : ('-> 'b) -> 'T(M).t -> 'T(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) -> 'T(M).t -> 'T(M).t -> 'T(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      'T(M).t ->
                      'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T(M).t ->
                      'T(M).t ->
                      'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                  end
                type 'a error = Core_kernel.Std.Error.t
                val fail : Core_kernel.Std.Error.t -> 'T(M).t
                val catch :
                  'T(M).t ->
                  (Core_kernel.Std.Error.t -> 'T(M).t) -> 'T(M).t
                val failf :
                  ('a, Format.formatter, unit, unit -> 'T(M).t)
                  Core_kernel.Std.format4 -> 'a
              end
          type 'a t = 'Core_kernel.Std.Or_error.t
          type 'a m = 'a
          type 'a e = 'a t
          val lift : '-> 'a e
          val run : 'a e -> 'a e
          val void : 'a e -> unit e
          val sequence : unit e list -> unit e
          val forever : 'a e -> 'b e
          module Fn :
            sig
              val id : '-> 'a e
              val ignore : 'a e -> unit e
              val nothing : unit -> unit e
              val non : ('-> bool e) -> '-> bool e
              val apply_n_times : n:int -> ('-> 'a e) -> '-> 'a e
              val compose : ('-> 'c e) -> ('-> 'b e) -> '-> 'c e
            end
          module Pair :
            sig
              val fst : ('a * 'b) e -> 'a e
              val snd : ('a * 'b) e -> 'b e
            end
          module Triple :
            sig
              val fst : ('a * 'b * 'c) e -> 'a e
              val snd : ('a * 'b * 'c) e -> 'b e
              val trd : ('a * 'b * 'c) e -> 'c e
            end
          module Lift :
            sig
              val nullary : '-> 'a e
              val unary : ('-> 'b) -> 'a e -> 'b e
              val binary : ('-> '-> 'c) -> 'a e -> 'b e -> 'c e
              val ternary :
                ('-> '-> '-> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
              val quaternary :
                ('-> '-> '-> '-> 'e) ->
                'a e -> 'b e -> 'c e -> 'd e -> 'e e
              val quinary :
                ('-> '-> '-> '-> '-> 'f) ->
                'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
            end
          module Exn :
            sig
              val expect :
                ?finally:(unit -> unit e) ->
                f:(unit -> 'a e) -> catch:(exn -> 'a e) -> 'a e
            end
          module Collection :
            sig
              module type S =
                sig
                  type 'a t
                  val all : 'a e t -> 'a t e
                  val all_ignore : 'a e t -> unit e
                  val sequence : unit e t -> unit e
                  val map : 'a t -> f:('-> 'b e) -> 'b t e
                  val iter : 'a t -> f:('-> unit e) -> unit e
                  val fold : 'a t -> init:'-> f:('-> '-> 'b e) -> 'b e
                  val fold_left :
                    'a t -> init:'-> f:('-> '-> 'b e) -> 'b e
                  val fold_right :
                    'a t -> f:('-> '-> 'b e) -> init:'-> 'b e
                  val reduce : 'a t -> f:('-> '-> 'a e) -> 'Option.t e
                  val exists : 'a t -> f:('-> bool e) -> bool e
                  val for_all : 'a t -> f:('-> bool e) -> bool e
                  val count : 'a t -> f:('-> bool e) -> int e
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b t -> f:('-> 'a e) -> 'a e
                  val find : 'a t -> f:('-> bool e) -> 'Option.t e
                  val find_map :
                    'a t -> f:('-> 'Option.t e) -> 'Option.t e
                  val filter : 'a t -> f:('-> bool e) -> 'a t e
                  val filter_map : 'a t -> f:('-> 'Option.t e) -> 'b t e
                end
              module Eager :
                functor (T : Collection.Eager->
                  sig
                    val all : 'a e T.t -> 'T.t e
                    val all_ignore : 'a e T.t -> unit e
                    val sequence : unit e T.t -> unit e
                    val map : 'T.t -> f:('-> 'b e) -> 'T.t e
                    val iter : 'T.t -> f:('-> unit e) -> unit e
                    val fold :
                      'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                    val fold_left :
                      'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                    val fold_right :
                      'T.t -> f:('-> '-> 'b e) -> init:'-> 'b e
                    val reduce :
                      'T.t -> f:('-> '-> 'a e) -> 'Option.t e
                    val exists : 'T.t -> f:('-> bool e) -> bool e
                    val for_all : 'T.t -> f:('-> bool e) -> bool e
                    val count : 'T.t -> f:('-> bool e) -> int e
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> 'a e) -> 'a e
                    val find : 'T.t -> f:('-> bool e) -> 'Option.t e
                    val find_map :
                      'T.t -> f:('-> 'Option.t e) -> 'Option.t e
                    val filter : 'T.t -> f:('-> bool e) -> 'T.t e
                    val filter_map :
                      'T.t -> f:('-> 'Option.t e) -> 'T.t e
                  end
              module Delay :
                functor (T : Collection.Delay->
                  sig
                    val all : 'a e T.t -> 'T.t e
                    val all_ignore : 'a e T.t -> unit e
                    val sequence : unit e T.t -> unit e
                    val map : 'T.t -> f:('-> 'b e) -> 'T.t e
                    val iter : 'T.t -> f:('-> unit e) -> unit e
                    val fold :
                      'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                    val fold_left :
                      'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                    val fold_right :
                      'T.t -> f:('-> '-> 'b e) -> init:'-> 'b e
                    val reduce :
                      'T.t -> f:('-> '-> 'a e) -> 'Option.t e
                    val exists : 'T.t -> f:('-> bool e) -> bool e
                    val for_all : 'T.t -> f:('-> bool e) -> bool e
                    val count : 'T.t -> f:('-> bool e) -> int e
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> 'a e) -> 'a e
                    val find : 'T.t -> f:('-> bool e) -> 'Option.t e
                    val find_map :
                      'T.t -> f:('-> 'Option.t e) -> 'Option.t e
                    val filter : 'T.t -> f:('-> bool e) -> 'T.t e
                    val filter_map :
                      'T.t -> f:('-> 'Option.t e) -> 'T.t e
                  end
            end
          module List :
            sig
              val all : 'a e list -> 'a list e
              val all_ignore : 'a e list -> unit e
              val sequence : unit e list -> unit e
              val map : 'a list -> f:('-> 'b e) -> 'b list e
              val iter : 'a list -> f:('-> unit e) -> unit e
              val fold : 'a list -> init:'-> f:('-> '-> 'b e) -> 'b e
              val fold_left :
                'a list -> init:'-> f:('-> '-> 'b e) -> 'b e
              val fold_right :
                'a list -> f:('-> '-> 'b e) -> init:'-> 'b e
              val reduce : 'a list -> f:('-> '-> 'a e) -> 'Option.t e
              val exists : 'a list -> f:('-> bool e) -> bool e
              val for_all : 'a list -> f:('-> bool e) -> bool e
              val count : 'a list -> f:('-> bool e) -> int e
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'b list -> f:('-> 'a e) -> 'a e
              val find : 'a list -> f:('-> bool e) -> 'Option.t e
              val find_map :
                'a list -> f:('-> 'Option.t e) -> 'Option.t e
              val filter : 'a list -> f:('-> bool e) -> 'a list e
              val filter_map :
                'a list -> f:('-> 'Option.t e) -> 'b list e
            end
          module Seq :
            sig
              val all :
                'a e Core_kernel.Std.Sequence.t ->
                'Core_kernel.Std.Sequence.t e
              val all_ignore : 'a e Core_kernel.Std.Sequence.t -> unit e
              val sequence : unit e Core_kernel.Std.Sequence.t -> unit e
              val map :
                'Core_kernel.Std.Sequence.t ->
                f:('-> 'b e) -> 'Core_kernel.Std.Sequence.t e
              val iter :
                'Core_kernel.Std.Sequence.t -> f:('-> unit e) -> unit e
              val fold :
                'Core_kernel.Std.Sequence.t ->
                init:'-> f:('-> '-> 'b e) -> 'b e
              val fold_left :
                'Core_kernel.Std.Sequence.t ->
                init:'-> f:('-> '-> 'b e) -> 'b e
              val fold_right :
                'Core_kernel.Std.Sequence.t ->
                f:('-> '-> 'b e) -> init:'-> 'b e
              val reduce :
                'Core_kernel.Std.Sequence.t ->
                f:('-> '-> 'a e) -> 'Option.t e
              val exists :
                'Core_kernel.Std.Sequence.t -> f:('-> bool e) -> bool e
              val for_all :
                'Core_kernel.Std.Sequence.t -> f:('-> bool e) -> bool e
              val count :
                'Core_kernel.Std.Sequence.t -> f:('-> bool e) -> int e
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'Core_kernel.Std.Sequence.t -> f:('-> 'a e) -> 'a e
              val find :
                'Core_kernel.Std.Sequence.t ->
                f:('-> bool e) -> 'Option.t e
              val find_map :
                'Core_kernel.Std.Sequence.t ->
                f:('-> 'Option.t e) -> 'Option.t e
              val filter :
                'Core_kernel.Std.Sequence.t ->
                f:('-> bool e) -> 'Core_kernel.Std.Sequence.t e
              val filter_map :
                'Core_kernel.Std.Sequence.t ->
                f:('-> 'Option.t e) -> 'Core_kernel.Std.Sequence.t e
            end
          val ( >=> ) : ('-> 'b e) -> ('-> 'c e) -> '-> 'c e
          val ( !! ) : '-> 'a e
          val ( !$ ) : ('-> 'b) -> 'a e -> 'b e
          val ( !$$ ) : ('-> '-> 'c) -> 'a e -> 'b e -> 'c e
          val ( !$$$ ) :
            ('-> '-> '-> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            'a e -> 'b e -> 'c e -> 'd e -> 'e e
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
          val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
          val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
          module Monad_infix :
            sig
              val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
              val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
            end
          val bind : 'a e -> f:('-> 'b e) -> 'b e
          val return : '-> 'a e
          val map : 'a e -> f:('-> 'b) -> 'b e
          val join : 'a e e -> 'a e
          val ignore_m : 'a e -> unit e
          val all : 'a e list -> 'a list e
          val all_ignore : unit e list -> unit e
          module Let_syntax :
            sig
              val return : '-> 'a e
              val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
              val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
              module Let_syntax :
                sig
                  val return : '-> 'a e
                  val bind : 'a e -> f:('-> 'b e) -> 'b e
                  val map : 'a e -> f:('-> 'b) -> 'b e
                  val both : 'a e -> 'b e -> ('a * 'b) e
                  module Open_on_rhs : sig  end
                end
            end
          module Syntax :
            sig
              val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
              val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
              val ( >=> ) : ('-> 'b e) -> ('-> 'c e) -> '-> 'c e
              val ( !! ) : '-> 'a e
              val ( !$ ) : ('-> 'b) -> 'a e -> 'b e
              val ( !$$ ) : ('-> '-> 'c) -> 'a e -> 'b e -> 'c e
              val ( !$$$ ) :
                ('-> '-> '-> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'a e -> 'b e -> 'c e -> 'd e -> 'e e
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
            end
          type 'a error = Core_kernel.Std.Error.t
          val fail : Core_kernel.Std.Error.t -> 'a e
          val catch : 'a e -> (Core_kernel.Std.Error.t -> 'a e) -> 'a e
          val failf :
            ('a, Format.formatter, unit, unit -> 'b e)
            Core_kernel.Std.format4 -> 'a
        end
      module Exception :
        sig
          type 'a t = ('a, exn) Core_kernel.Std.Result.t
          type 'a m = 'a
          type 'a e = ('a, exn) Core_kernel.Std.Result.t
          val lift : '-> 'a t
          val run : 'a t -> 'a e
          val void : 'a t -> unit t
          val sequence : unit t list -> unit t
          val forever : 'a t -> 'b t
          module Fn :
            sig
              val id : '-> 'a t
              val ignore : 'a t -> unit t
              val nothing : unit -> unit t
              val non : ('-> bool t) -> '-> bool t
              val apply_n_times : n:int -> ('-> 'a t) -> '-> 'a t
              val compose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
            end
          module Pair :
            sig
              val fst : ('a * 'b) t -> 'a t
              val snd : ('a * 'b) t -> 'b t
            end
          module Triple :
            sig
              val fst : ('a * 'b * 'c) t -> 'a t
              val snd : ('a * 'b * 'c) t -> 'b t
              val trd : ('a * 'b * 'c) t -> 'c t
            end
          module Lift :
            sig
              val nullary : '-> 'a t
              val unary : ('-> 'b) -> 'a t -> 'b t
              val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ternary :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val quaternary :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val quinary :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
            end
          module Exn :
            sig
              val expect :
                ?finally:(unit -> unit t) ->
                f:(unit -> 'a t) -> catch:(exn -> 'a t) -> 'a t
            end
          module Collection :
            sig
              module type S =
                sig
                  type 'a t
                  val all : 'a t t -> 'a t t
                  val all_ignore : 'a t t -> unit t
                  val sequence : unit t t -> unit t
                  val map : 'a t -> f:('-> 'b t) -> 'b t t
                  val iter : 'a t -> f:('-> unit t) -> unit t
                  val fold : 'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce : 'a t -> f:('-> '-> 'a t) -> 'Option.t t
                  val exists : 'a t -> f:('-> bool t) -> bool t
                  val for_all : 'a t -> f:('-> bool t) -> bool t
                  val count : 'a t -> f:('-> bool t) -> int t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b t -> f:('-> 'a t) -> 'a t
                  val find : 'a t -> f:('-> bool t) -> 'Option.t t
                  val find_map :
                    'a t -> f:('-> 'Option.t t) -> 'Option.t t
                  val filter : 'a t -> f:('-> bool t) -> 'a t t
                  val filter_map : 'a t -> f:('-> 'Option.t t) -> 'b t t
                end
              module Eager :
                functor (T : Collection.Eager->
                  sig
                    val all : 'a t T.t -> 'T.t t
                    val all_ignore : 'a t T.t -> unit t
                    val sequence : unit t T.t -> unit t
                    val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                    val iter : 'T.t -> f:('-> unit t) -> unit t
                    val fold :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_left :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_right :
                      'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                    val reduce :
                      'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                    val exists : 'T.t -> f:('-> bool t) -> bool t
                    val for_all : 'T.t -> f:('-> bool t) -> bool t
                    val count : 'T.t -> f:('-> bool t) -> int t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> 'a t) -> 'a t
                    val find : 'T.t -> f:('-> bool t) -> 'Option.t t
                    val find_map :
                      'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                    val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                    val filter_map :
                      'T.t -> f:('-> 'Option.t t) -> 'T.t t
                  end
              module Delay :
                functor (T : Collection.Delay->
                  sig
                    val all : 'a t T.t -> 'T.t t
                    val all_ignore : 'a t T.t -> unit t
                    val sequence : unit t T.t -> unit t
                    val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                    val iter : 'T.t -> f:('-> unit t) -> unit t
                    val fold :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_left :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_right :
                      'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                    val reduce :
                      'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                    val exists : 'T.t -> f:('-> bool t) -> bool t
                    val for_all : 'T.t -> f:('-> bool t) -> bool t
                    val count : 'T.t -> f:('-> bool t) -> int t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> 'a t) -> 'a t
                    val find : 'T.t -> f:('-> bool t) -> 'Option.t t
                    val find_map :
                      'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                    val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                    val filter_map :
                      'T.t -> f:('-> 'Option.t t) -> 'T.t t
                  end
            end
          module List :
            sig
              val all : 'a t list -> 'a list t
              val all_ignore : 'a t list -> unit t
              val sequence : unit t list -> unit t
              val map : 'a list -> f:('-> 'b t) -> 'b list t
              val iter : 'a list -> f:('-> unit t) -> unit t
              val fold : 'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_left :
                'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_right :
                'a list -> f:('-> '-> 'b t) -> init:'-> 'b t
              val reduce : 'a list -> f:('-> '-> 'a t) -> 'Option.t t
              val exists : 'a list -> f:('-> bool t) -> bool t
              val for_all : 'a list -> f:('-> bool t) -> bool t
              val count : 'a list -> f:('-> bool t) -> int t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'b list -> f:('-> 'a t) -> 'a t
              val find : 'a list -> f:('-> bool t) -> 'Option.t t
              val find_map :
                'a list -> f:('-> 'Option.t t) -> 'Option.t t
              val filter : 'a list -> f:('-> bool t) -> 'a list t
              val filter_map :
                'a list -> f:('-> 'Option.t t) -> 'b list t
            end
          module Seq :
            sig
              val all :
                'a t Core_kernel.Std.Sequence.t ->
                'Core_kernel.Std.Sequence.t t
              val all_ignore : 'a t Core_kernel.Std.Sequence.t -> unit t
              val sequence : unit t Core_kernel.Std.Sequence.t -> unit t
              val map :
                'Core_kernel.Std.Sequence.t ->
                f:('-> 'b t) -> 'Core_kernel.Std.Sequence.t t
              val iter :
                'Core_kernel.Std.Sequence.t -> f:('-> unit t) -> unit t
              val fold :
                'Core_kernel.Std.Sequence.t ->
                init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_left :
                'Core_kernel.Std.Sequence.t ->
                init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_right :
                'Core_kernel.Std.Sequence.t ->
                f:('-> '-> 'b t) -> init:'-> 'b t
              val reduce :
                'Core_kernel.Std.Sequence.t ->
                f:('-> '-> 'a t) -> 'Option.t t
              val exists :
                'Core_kernel.Std.Sequence.t -> f:('-> bool t) -> bool t
              val for_all :
                'Core_kernel.Std.Sequence.t -> f:('-> bool t) -> bool t
              val count :
                'Core_kernel.Std.Sequence.t -> f:('-> bool t) -> int t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'Core_kernel.Std.Sequence.t -> f:('-> 'a t) -> 'a t
              val find :
                'Core_kernel.Std.Sequence.t ->
                f:('-> bool t) -> 'Option.t t
              val find_map :
                'Core_kernel.Std.Sequence.t ->
                f:('-> 'Option.t t) -> 'Option.t t
              val filter :
                'Core_kernel.Std.Sequence.t ->
                f:('-> bool t) -> 'Core_kernel.Std.Sequence.t t
              val filter_map :
                'Core_kernel.Std.Sequence.t ->
                f:('-> 'Option.t t) -> 'Core_kernel.Std.Sequence.t t
            end
          val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
          val ( !! ) : '-> 'a t
          val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
          val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
          val ( !$$$ ) :
            ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            'a t -> 'b t -> 'c t -> 'd t -> 'e t
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
          val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
          val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
          module Monad_infix :
            sig
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
            end
          val bind : 'a t -> f:('-> 'b t) -> 'b t
          val return : '-> 'a t
          val map : 'a t -> f:('-> 'b) -> 'b t
          val join : 'a t t -> 'a t
          val ignore_m : 'a t -> unit t
          val all : 'a t list -> 'a list t
          val all_ignore : unit t list -> unit t
          module Let_syntax :
            sig
              val return : '-> 'a t
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              module Let_syntax :
                sig
                  val return : '-> 'a t
                  val bind : 'a t -> f:('-> 'b t) -> 'b t
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val both : 'a t -> 'b t -> ('a * 'b) t
                  module Open_on_rhs : sig  end
                end
            end
          module Syntax :
            sig
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
              val ( !! ) : '-> 'a t
              val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
              val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
            end
          type 'a error = exn
          val fail : exn -> 'a t
          val catch : 'a t -> (exn -> 'a t) -> 'a t
          module T :
            functor (M : Monad->
              sig
                type 'a m = 'M.t
                type 'a t =
                    ('a, exn) Core_kernel.Std.Result.t
                    Monads.Std.Monad.Result.Exception.T.m
                type 'a e =
                    ('a, exn) Core_kernel.Std.Result.t
                    Monads.Std.Monad.Result.Exception.T.m
              end
          module Make :
            functor (M : Monad->
              sig
                val lift : 'M.t -> 'T(M).t
                val run : 'T(M).t -> 'T(M).e
                val void : 'T(M).t -> unit T(M).t
                val sequence : unit T(M).t list -> unit T(M).t
                val forever : 'T(M).t -> 'T(M).t
                module Fn :
                  sig
                    val id : '-> 'T(M).t
                    val ignore : 'T(M).t -> unit T(M).t
                    val nothing : unit -> unit T(M).t
                    val non : ('-> bool T(M).t) -> '-> bool T(M).t
                    val apply_n_times :
                      n:int -> ('-> 'T(M).t) -> '-> 'T(M).t
                    val compose :
                      ('-> 'T(M).t) ->
                      ('-> 'T(M).t) -> '-> 'T(M).t
                  end
                module Pair :
                  sig
                    val fst : ('a * 'b) T(M).t -> 'T(M).t
                    val snd : ('a * 'b) T(M).t -> 'T(M).t
                  end
                module Triple :
                  sig
                    val fst : ('a * 'b * 'c) T(M).t -> 'T(M).t
                    val snd : ('a * 'b * 'c) T(M).t -> 'T(M).t
                    val trd : ('a * 'b * 'c) T(M).t -> 'T(M).t
                  end
                module Lift :
                  sig
                    val nullary : '-> 'T(M).t
                    val unary : ('-> 'b) -> 'T(M).t -> 'T(M).t
                    val binary :
                      ('-> '-> 'c) -> 'T(M).t -> 'T(M).t -> 'T(M).t
                    val ternary :
                      ('-> '-> '-> 'd) ->
                      'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                    val quaternary :
                      ('-> '-> '-> '-> 'e) ->
                      'T(M).t ->
                      'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                    val quinary :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T(M).t ->
                      'T(M).t ->
                      'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                  end
                module Exn :
                  sig
                    val expect :
                      ?finally:(unit -> unit T(M).t) ->
                      f:(unit -> 'T(M).t) ->
                      catch:(exn -> 'T(M).t) -> 'T(M).t
                  end
                module Collection :
                  sig
                    module type S =
                      sig
                        type 'a t
                        val all : 'T(M).t t -> 'a t T(M).t
                        val all_ignore : 'T(M).t t -> unit T(M).t
                        val sequence : unit T(M).t t -> unit T(M).t
                        val map : 'a t -> f:('-> 'T(M).t) -> 'b t T(M).t
                        val iter :
                          'a t -> f:('-> unit T(M).t) -> unit T(M).t
                        val fold :
                          'a t ->
                          init:'-> f:('-> '-> 'T(M).t) -> 'T(M).t
                        val fold_left :
                          'a t ->
                          init:'-> f:('-> '-> 'T(M).t) -> 'T(M).t
                        val fold_right :
                          'a t ->
                          f:('-> '-> 'T(M).t) -> init:'-> 'T(M).t
                        val reduce :
                          'a t ->
                          f:('-> '-> 'T(M).t) -> 'Option.t T(M).t
                        val exists :
                          'a t -> f:('-> bool T(M).t) -> bool T(M).t
                        val for_all :
                          'a t -> f:('-> bool T(M).t) -> bool T(M).t
                        val count :
                          'a t -> f:('-> bool T(M).t) -> int T(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b t -> f:('-> 'T(M).t) -> 'T(M).t
                        val find :
                          'a t -> f:('-> bool T(M).t) -> 'Option.t T(M).t
                        val find_map :
                          'a t ->
                          f:('-> 'Option.t T(M).t) -> 'Option.t T(M).t
                        val filter :
                          'a t -> f:('-> bool T(M).t) -> 'a t T(M).t
                        val filter_map :
                          'a t -> f:('-> 'Option.t T(M).t) -> 'b t T(M).t
                      end
                    module Eager :
                      functor (T : Collection.Eager->
                        sig
                          val all : 'T(M).t T.t -> 'T.t T(M).t
                          val all_ignore : 'T(M).t T.t -> unit T(M).t
                          val sequence : unit T(M).t T.t -> unit T(M).t
                          val map :
                            'T.t -> f:('-> 'T(M).t) -> 'T.t T(M).t
                          val iter :
                            'T.t -> f:('-> unit T(M).t) -> unit T(M).t
                          val fold :
                            'T.t ->
                            init:'-> f:('-> '-> 'T(M).t) -> 'T(M).t
                          val fold_left :
                            'T.t ->
                            init:'-> f:('-> '-> 'T(M).t) -> 'T(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> 'T(M).t) -> init:'-> 'T(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> 'T(M).t) -> 'Option.t T(M).t
                          val exists :
                            'T.t -> f:('-> bool T(M).t) -> bool T(M).t
                          val for_all :
                            'T.t -> f:('-> bool T(M).t) -> bool T(M).t
                          val count :
                            'T.t -> f:('-> bool T(M).t) -> int T(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t -> f:('-> 'T(M).t) -> 'T(M).t
                          val find :
                            'T.t ->
                            f:('-> bool T(M).t) -> 'Option.t T(M).t
                          val find_map :
                            'T.t ->
                            f:('-> 'Option.t T(M).t) ->
                            'Option.t T(M).t
                          val filter :
                            'T.t -> f:('-> bool T(M).t) -> 'T.t T(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> 'Option.t T(M).t) -> 'T.t T(M).t
                        end
                    module Delay :
                      functor (T : Collection.Delay->
                        sig
                          val all : 'T(M).t T.t -> 'T.t T(M).t
                          val all_ignore : 'T(M).t T.t -> unit T(M).t
                          val sequence : unit T(M).t T.t -> unit T(M).t
                          val map :
                            'T.t -> f:('-> 'T(M).t) -> 'T.t T(M).t
                          val iter :
                            'T.t -> f:('-> unit T(M).t) -> unit T(M).t
                          val fold :
                            'T.t ->
                            init:'-> f:('-> '-> 'T(M).t) -> 'T(M).t
                          val fold_left :
                            'T.t ->
                            init:'-> f:('-> '-> 'T(M).t) -> 'T(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> 'T(M).t) -> init:'-> 'T(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> 'T(M).t) -> 'Option.t T(M).t
                          val exists :
                            'T.t -> f:('-> bool T(M).t) -> bool T(M).t
                          val for_all :
                            'T.t -> f:('-> bool T(M).t) -> bool T(M).t
                          val count :
                            'T.t -> f:('-> bool T(M).t) -> int T(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t -> f:('-> 'T(M).t) -> 'T(M).t
                          val find :
                            'T.t ->
                            f:('-> bool T(M).t) -> 'Option.t T(M).t
                          val find_map :
                            'T.t ->
                            f:('-> 'Option.t T(M).t) ->
                            'Option.t T(M).t
                          val filter :
                            'T.t -> f:('-> bool T(M).t) -> 'T.t T(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> 'Option.t T(M).t) -> 'T.t T(M).t
                        end
                  end
                module List :
                  sig
                    val all : 'T(M).t list -> 'a list T(M).t
                    val all_ignore : 'T(M).t list -> unit T(M).t
                    val sequence : unit T(M).t list -> unit T(M).t
                    val map :
                      'a list -> f:('-> 'T(M).t) -> 'b list T(M).t
                    val iter :
                      'a list -> f:('-> unit T(M).t) -> unit T(M).t
                    val fold :
                      'a list ->
                      init:'-> f:('-> '-> 'T(M).t) -> 'T(M).t
                    val fold_left :
                      'a list ->
                      init:'-> f:('-> '-> 'T(M).t) -> 'T(M).t
                    val fold_right :
                      'a list ->
                      f:('-> '-> 'T(M).t) -> init:'-> 'T(M).t
                    val reduce :
                      'a list ->
                      f:('-> '-> 'T(M).t) -> 'Option.t T(M).t
                    val exists :
                      'a list -> f:('-> bool T(M).t) -> bool T(M).t
                    val for_all :
                      'a list -> f:('-> bool T(M).t) -> bool T(M).t
                    val count :
                      'a list -> f:('-> bool T(M).t) -> int T(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b list -> f:('-> 'T(M).t) -> 'T(M).t
                    val find :
                      'a list -> f:('-> bool T(M).t) -> 'Option.t T(M).t
                    val find_map :
                      'a list ->
                      f:('-> 'Option.t T(M).t) -> 'Option.t T(M).t
                    val filter :
                      'a list -> f:('-> bool T(M).t) -> 'a list T(M).t
                    val filter_map :
                      'a list ->
                      f:('-> 'Option.t T(M).t) -> 'b list T(M).t
                  end
                module Seq :
                  sig
                    val all :
                      'T(M).t Core_kernel.Std.Sequence.t ->
                      'Core_kernel.Std.Sequence.t T(M).t
                    val all_ignore :
                      'T(M).t Core_kernel.Std.Sequence.t -> unit T(M).t
                    val sequence :
                      unit T(M).t Core_kernel.Std.Sequence.t -> unit T(M).t
                    val map :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> 'T(M).t) ->
                      'Core_kernel.Std.Sequence.t T(M).t
                    val iter :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> unit T(M).t) -> unit T(M).t
                    val fold :
                      'Core_kernel.Std.Sequence.t ->
                      init:'-> f:('-> '-> 'T(M).t) -> 'T(M).t
                    val fold_left :
                      'Core_kernel.Std.Sequence.t ->
                      init:'-> f:('-> '-> 'T(M).t) -> 'T(M).t
                    val fold_right :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> '-> 'T(M).t) -> init:'-> 'T(M).t
                    val reduce :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> '-> 'T(M).t) -> 'Option.t T(M).t
                    val exists :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> bool T(M).t) -> bool T(M).t
                    val for_all :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> bool T(M).t) -> bool T(M).t
                    val count :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> bool T(M).t) -> int T(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> 'T(M).t) -> 'T(M).t
                    val find :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> bool T(M).t) -> 'Option.t T(M).t
                    val find_map :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> 'Option.t T(M).t) -> 'Option.t T(M).t
                    val filter :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> bool T(M).t) ->
                      'Core_kernel.Std.Sequence.t T(M).t
                    val filter_map :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> 'Option.t T(M).t) ->
                      'Core_kernel.Std.Sequence.t T(M).t
                  end
                val ( >=> ) :
                  ('-> 'T(M).t) -> ('-> 'T(M).t) -> '-> 'T(M).t
                val ( !! ) : '-> 'T(M).t
                val ( !$ ) : ('-> 'b) -> 'T(M).t -> 'T(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) -> 'T(M).t -> 'T(M).t -> 'T(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  'T(M).t ->
                  'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'T(M).t ->
                  'T(M).t ->
                  'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                val ( >>= ) : 'T(M).t -> ('-> 'T(M).t) -> 'T(M).t
                val ( >>| ) : 'T(M).t -> ('-> 'b) -> 'T(M).t
                module Monad_infix :
                  sig
                    val ( >>= ) : 'T(M).t -> ('-> 'T(M).t) -> 'T(M).t
                    val ( >>| ) : 'T(M).t -> ('-> 'b) -> 'T(M).t
                  end
                val bind : 'T(M).t -> f:('-> 'T(M).t) -> 'T(M).t
                val return : '-> 'T(M).t
                val map : 'T(M).t -> f:('-> 'b) -> 'T(M).t
                val join : 'T(M).t T(M).t -> 'T(M).t
                val ignore_m : 'T(M).t -> unit T(M).t
                val all : 'T(M).t list -> 'a list T(M).t
                val all_ignore : unit T(M).t list -> unit T(M).t
                module Let_syntax :
                  sig
                    val return : '-> 'T(M).t
                    val ( >>= ) : 'T(M).t -> ('-> 'T(M).t) -> 'T(M).t
                    val ( >>| ) : 'T(M).t -> ('-> 'b) -> 'T(M).t
                    module Let_syntax :
                      sig
                        val return : '-> 'T(M).t
                        val bind :
                          'T(M).t -> f:('-> 'T(M).t) -> 'T(M).t
                        val map : 'T(M).t -> f:('-> 'b) -> 'T(M).t
                        val both : 'T(M).t -> 'T(M).t -> ('a * 'b) T(M).t
                        module Open_on_rhs : sig  end
                      end
                  end
                module Syntax :
                  sig
                    val ( >>= ) : 'T(M).t -> ('-> 'T(M).t) -> 'T(M).t
                    val ( >>| ) : 'T(M).t -> ('-> 'b) -> 'T(M).t
                    val ( >=> ) :
                      ('-> 'T(M).t) ->
                      ('-> 'T(M).t) -> '-> 'T(M).t
                    val ( !! ) : '-> 'T(M).t
                    val ( !$ ) : ('-> 'b) -> 'T(M).t -> 'T(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) -> 'T(M).t -> 'T(M).t -> 'T(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      'T(M).t ->
                      'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T(M).t ->
                      'T(M).t ->
                      'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                  end
                type 'a error = exn
                val fail : exn -> 'T(M).t
                val catch : 'T(M).t -> (exn -> 'T(M).t) -> 'T(M).t
              end
        end
    end
  module List :
    sig
      module type S =
        sig
          type 'a t
          type 'a m
          type 'a e
          val lift : 'a m -> 'a t
          val run : 'a t -> 'a e
          val void : 'a t -> unit t
          val sequence : unit t list -> unit t
          val forever : 'a t -> 'b t
          module Fn :
            sig
              val id : '-> 'a t
              val ignore : 'a t -> unit t
              val nothing : unit -> unit t
              val non : ('-> bool t) -> '-> bool t
              val apply_n_times : n:int -> ('-> 'a t) -> '-> 'a t
              val compose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
            end
          module Pair :
            sig
              val fst : ('a * 'b) t -> 'a t
              val snd : ('a * 'b) t -> 'b t
            end
          module Triple :
            sig
              val fst : ('a * 'b * 'c) t -> 'a t
              val snd : ('a * 'b * 'c) t -> 'b t
              val trd : ('a * 'b * 'c) t -> 'c t
            end
          module Lift :
            sig
              val nullary : '-> 'a t
              val unary : ('-> 'b) -> 'a t -> 'b t
              val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ternary :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val quaternary :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val quinary :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
            end
          module Exn :
            sig
              val expect :
                ?finally:(unit -> unit t) ->
                f:(unit -> 'a t) -> catch:(exn -> 'a t) -> 'a t
            end
          module Collection :
            sig
              module type S =
                sig
                  type 'a t
                  val all : 'a t t -> 'a t t
                  val all_ignore : 'a t t -> unit t
                  val sequence : unit t t -> unit t
                  val map : 'a t -> f:('-> 'b t) -> 'b t t
                  val iter : 'a t -> f:('-> unit t) -> unit t
                  val fold : 'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce : 'a t -> f:('-> '-> 'a t) -> 'Option.t t
                  val exists : 'a t -> f:('-> bool t) -> bool t
                  val for_all : 'a t -> f:('-> bool t) -> bool t
                  val count : 'a t -> f:('-> bool t) -> int t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b t -> f:('-> 'a t) -> 'a t
                  val find : 'a t -> f:('-> bool t) -> 'Option.t t
                  val find_map :
                    'a t -> f:('-> 'Option.t t) -> 'Option.t t
                  val filter : 'a t -> f:('-> bool t) -> 'a t t
                  val filter_map : 'a t -> f:('-> 'Option.t t) -> 'b t t
                end
              module Eager :
                functor (T : Collection.Eager->
                  sig
                    val all : 'a t T.t -> 'T.t t
                    val all_ignore : 'a t T.t -> unit t
                    val sequence : unit t T.t -> unit t
                    val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                    val iter : 'T.t -> f:('-> unit t) -> unit t
                    val fold :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_left :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_right :
                      'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                    val reduce :
                      'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                    val exists : 'T.t -> f:('-> bool t) -> bool t
                    val for_all : 'T.t -> f:('-> bool t) -> bool t
                    val count : 'T.t -> f:('-> bool t) -> int t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> 'a t) -> 'a t
                    val find : 'T.t -> f:('-> bool t) -> 'Option.t t
                    val find_map :
                      'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                    val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                    val filter_map :
                      'T.t -> f:('-> 'Option.t t) -> 'T.t t
                  end
              module Delay :
                functor (T : Collection.Delay->
                  sig
                    val all : 'a t T.t -> 'T.t t
                    val all_ignore : 'a t T.t -> unit t
                    val sequence : unit t T.t -> unit t
                    val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                    val iter : 'T.t -> f:('-> unit t) -> unit t
                    val fold :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_left :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_right :
                      'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                    val reduce :
                      'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                    val exists : 'T.t -> f:('-> bool t) -> bool t
                    val for_all : 'T.t -> f:('-> bool t) -> bool t
                    val count : 'T.t -> f:('-> bool t) -> int t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> 'a t) -> 'a t
                    val find : 'T.t -> f:('-> bool t) -> 'Option.t t
                    val find_map :
                      'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                    val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                    val filter_map :
                      'T.t -> f:('-> 'Option.t t) -> 'T.t t
                  end
            end
          module List :
            sig
              val all : 'a t list -> 'a list t
              val all_ignore : 'a t list -> unit t
              val sequence : unit t list -> unit t
              val map : 'a list -> f:('-> 'b t) -> 'b list t
              val iter : 'a list -> f:('-> unit t) -> unit t
              val fold : 'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_left :
                'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_right :
                'a list -> f:('-> '-> 'b t) -> init:'-> 'b t
              val reduce : 'a list -> f:('-> '-> 'a t) -> 'Option.t t
              val exists : 'a list -> f:('-> bool t) -> bool t
              val for_all : 'a list -> f:('-> bool t) -> bool t
              val count : 'a list -> f:('-> bool t) -> int t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'b list -> f:('-> 'a t) -> 'a t
              val find : 'a list -> f:('-> bool t) -> 'Option.t t
              val find_map :
                'a list -> f:('-> 'Option.t t) -> 'Option.t t
              val filter : 'a list -> f:('-> bool t) -> 'a list t
              val filter_map :
                'a list -> f:('-> 'Option.t t) -> 'b list t
            end
          module Seq :
            sig
              val all :
                'a t Core_kernel.Std.Sequence.t ->
                'Core_kernel.Std.Sequence.t t
              val all_ignore : 'a t Core_kernel.Std.Sequence.t -> unit t
              val sequence : unit t Core_kernel.Std.Sequence.t -> unit t
              val map :
                'Core_kernel.Std.Sequence.t ->
                f:('-> 'b t) -> 'Core_kernel.Std.Sequence.t t
              val iter :
                'Core_kernel.Std.Sequence.t -> f:('-> unit t) -> unit t
              val fold :
                'Core_kernel.Std.Sequence.t ->
                init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_left :
                'Core_kernel.Std.Sequence.t ->
                init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_right :
                'Core_kernel.Std.Sequence.t ->
                f:('-> '-> 'b t) -> init:'-> 'b t
              val reduce :
                'Core_kernel.Std.Sequence.t ->
                f:('-> '-> 'a t) -> 'Option.t t
              val exists :
                'Core_kernel.Std.Sequence.t -> f:('-> bool t) -> bool t
              val for_all :
                'Core_kernel.Std.Sequence.t -> f:('-> bool t) -> bool t
              val count :
                'Core_kernel.Std.Sequence.t -> f:('-> bool t) -> int t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'Core_kernel.Std.Sequence.t -> f:('-> 'a t) -> 'a t
              val find :
                'Core_kernel.Std.Sequence.t ->
                f:('-> bool t) -> 'Option.t t
              val find_map :
                'Core_kernel.Std.Sequence.t ->
                f:('-> 'Option.t t) -> 'Option.t t
              val filter :
                'Core_kernel.Std.Sequence.t ->
                f:('-> bool t) -> 'Core_kernel.Std.Sequence.t t
              val filter_map :
                'Core_kernel.Std.Sequence.t ->
                f:('-> 'Option.t t) -> 'Core_kernel.Std.Sequence.t t
            end
          val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
          val ( !! ) : '-> 'a t
          val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
          val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
          val ( !$$$ ) :
            ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            'a t -> 'b t -> 'c t -> 'd t -> 'e t
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
          val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
          val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
          module Monad_infix :
            sig
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
            end
          val bind : 'a t -> f:('-> 'b t) -> 'b t
          val return : '-> 'a t
          val map : 'a t -> f:('-> 'b) -> 'b t
          val join : 'a t t -> 'a t
          val ignore_m : 'a t -> unit t
          val all : 'a t list -> 'a list t
          val all_ignore : unit t list -> unit t
          module Let_syntax :
            sig
              val return : '-> 'a t
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              module Let_syntax :
                sig
                  val return : '-> 'a t
                  val bind : 'a t -> f:('-> 'b t) -> 'b t
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val both : 'a t -> 'b t -> ('a * 'b) t
                  module Open_on_rhs : sig  end
                end
            end
          module Syntax :
            sig
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
              val ( !! ) : '-> 'a t
              val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
              val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
            end
          val pure : '-> 'a t
          val accept : '-> 'a t
          val reject : unit -> 'a t
          val guard : bool -> unit t
          val on : bool -> unit t -> unit t
          val unless : bool -> unit t -> unit t
          val zero : unit -> 'a t
          val plus : 'a t -> 'a t -> 'a t
        end
      module type S2 =
        sig
          type ('a, 'e) t
          type ('a, 'e) m
          type ('a, 'e) e
          val lift : ('a, 'e) m -> ('a, 'e) t
          val run : ('a, 'e) t -> ('a, 'e) e
          val void : ('a, 'e) t -> (unit, 'e) t
          val sequence : (unit, 'e) t list -> (unit, 'e) t
          val forever : ('a, 'e) t -> ('b, 'e) t
          module Fn :
            sig
              val id : '-> ('a, 'e) t
              val ignore : ('a, 'e) t -> (unit, 'e) t
              val nothing : unit -> (unit, 'e) t
              val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
              val apply_n_times :
                n:int -> ('-> ('a, 'e) t) -> '-> ('a, 'e) t
              val compose :
                ('-> ('c, 'e) t) -> ('-> ('b, 'e) t) -> '-> ('c, 'e) t
            end
          module Pair :
            sig
              val fst : ('a * 'b, 'e) t -> ('a, 'e) t
              val snd : ('a * 'b, 'e) t -> ('b, 'e) t
            end
          module Triple :
            sig
              val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
              val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
              val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
            end
          module Lift :
            sig
              val nullary : '-> ('a, 'e) t
              val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val binary :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ternary :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val quaternary :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val quinary :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
            end
          module Exn :
            sig
              val expect :
                ?finally:(unit -> (unit, 's) t) ->
                f:(unit -> ('a, 's) t) ->
                catch:(exn -> ('a, 's) t) -> ('a, 's) t
            end
          module Collection :
            sig
              module type S =
                sig
                  type 'a t
                  val all : ('a, 'e) t t -> ('a t, 'e) t
                  val all_ignore : ('a, 'e) t t -> (unit, 'e) t
                  val sequence : (unit, 'e) t t -> (unit, 'e) t
                  val map : 'a t -> f:('-> ('b, 'e) t) -> ('b t, 'e) t
                  val iter : 'a t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                  val fold :
                    'a t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'a t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'a t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'a t -> f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                  val exists : 'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count : 'a t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'a t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                  val find_map :
                    'a t ->
                    f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                  val filter : 'a t -> f:('-> (bool, 'e) t) -> ('a t, 'e) t
                  val filter_map :
                    'a t -> f:('-> ('Option.t, 'e) t) -> ('b t, 'e) t
                end
              module Eager :
                functor (T : Collection.Eager->
                  sig
                    val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                    val all_ignore : ('a, 'e) t T.t -> (unit, 'e) t
                    val sequence : (unit, 'e) t T.t -> (unit, 'e) t
                    val map :
                      'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                    val iter :
                      'T.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                    val fold :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_left :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_right :
                      'T.t ->
                      f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                    val reduce :
                      'T.t ->
                      f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                    val exists :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val for_all :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val count :
                      'T.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                    val find :
                      'T.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                    val find_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                    val filter :
                      'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                    val filter_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                  end
              module Delay :
                functor (T : Collection.Delay->
                  sig
                    val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                    val all_ignore : ('a, 'e) t T.t -> (unit, 'e) t
                    val sequence : (unit, 'e) t T.t -> (unit, 'e) t
                    val map :
                      'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                    val iter :
                      'T.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                    val fold :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_left :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_right :
                      'T.t ->
                      f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                    val reduce :
                      'T.t ->
                      f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                    val exists :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val for_all :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val count :
                      'T.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                    val find :
                      'T.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                    val find_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                    val filter :
                      'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                    val filter_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                  end
            end
          module List :
            sig
              val all : ('a, 'e) t list -> ('a list, 'e) t
              val all_ignore : ('a, 'e) t list -> (unit, 'e) t
              val sequence : (unit, 'e) t list -> (unit, 'e) t
              val map : 'a list -> f:('-> ('b, 'e) t) -> ('b list, 'e) t
              val iter : 'a list -> f:('-> (unit, 'e) t) -> (unit, 'e) t
              val fold :
                'a list ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_left :
                'a list ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_right :
                'a list ->
                f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
              val reduce :
                'a list -> f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
              val exists : 'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val for_all : 'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val count : 'a list -> f:('-> (bool, 'e) t) -> (int, 'e) t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'b list -> f:('-> ('a, 'e) t) -> ('a, 'e) t
              val find :
                'a list -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
              val find_map :
                'a list ->
                f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
              val filter :
                'a list -> f:('-> (bool, 'e) t) -> ('a list, 'e) t
              val filter_map :
                'a list -> f:('-> ('Option.t, 'e) t) -> ('b list, 'e) t
            end
          module Seq :
            sig
              val all :
                ('a, 'e) t Core_kernel.Std.Sequence.t ->
                ('Core_kernel.Std.Sequence.t, 'e) t
              val all_ignore :
                ('a, 'e) t Core_kernel.Std.Sequence.t -> (unit, 'e) t
              val sequence :
                (unit, 'e) t Core_kernel.Std.Sequence.t -> (unit, 'e) t
              val map :
                'Core_kernel.Std.Sequence.t ->
                f:('-> ('b, 'e) t) -> ('Core_kernel.Std.Sequence.t, 'e) t
              val iter :
                'Core_kernel.Std.Sequence.t ->
                f:('-> (unit, 'e) t) -> (unit, 'e) t
              val fold :
                'Core_kernel.Std.Sequence.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_left :
                'Core_kernel.Std.Sequence.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_right :
                'Core_kernel.Std.Sequence.t ->
                f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
              val reduce :
                'Core_kernel.Std.Sequence.t ->
                f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
              val exists :
                'Core_kernel.Std.Sequence.t ->
                f:('-> (bool, 'e) t) -> (bool, 'e) t
              val for_all :
                'Core_kernel.Std.Sequence.t ->
                f:('-> (bool, 'e) t) -> (bool, 'e) t
              val count :
                'Core_kernel.Std.Sequence.t ->
                f:('-> (bool, 'e) t) -> (int, 'e) t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'Core_kernel.Std.Sequence.t ->
                f:('-> ('a, 'e) t) -> ('a, 'e) t
              val find :
                'Core_kernel.Std.Sequence.t ->
                f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
              val find_map :
                'Core_kernel.Std.Sequence.t ->
                f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
              val filter :
                'Core_kernel.Std.Sequence.t ->
                f:('-> (bool, 'e) t) ->
                ('Core_kernel.Std.Sequence.t, 'e) t
              val filter_map :
                'Core_kernel.Std.Sequence.t ->
                f:('-> ('Option.t, 'e) t) ->
                ('Core_kernel.Std.Sequence.t, 'e) t
            end
          val ( >=> ) :
            ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
          val ( !! ) : '-> ('a, 'e) t
          val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
          val ( !$$ ) :
            ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
          val ( !$$$ ) :
            ('-> '-> '-> 'd) ->
            ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            ('a, 's) t ->
            ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            ('a, 's) t ->
            ('b, 's) t ->
            ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
          val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
          val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
          module Let_syntax :
            sig
              val return : '-> ('a, 'b) t
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              module Let_syntax :
                sig
                  val return : '-> ('a, 'b) t
                  val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                  val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                  val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                  module Open_on_rhs : sig  end
                end
            end
          module Monad_infix :
            sig
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
            end
          val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
          val return : '-> ('a, 'b) t
          val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
          val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
          val ignore_m : ('a, 'e) t -> (unit, 'e) t
          val all : ('a, 'e) t list -> ('a list, 'e) t
          val all_ignore : (unit, 'e) t list -> (unit, 'e) t
          module Syntax :
            sig
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              val ( >=> ) :
                ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
              val ( !! ) : '-> ('a, 'e) t
              val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val ( !$$ ) :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
            end
          val pure : '-> ('a, 'e) t
          val accept : '-> ('a, 'e) t
          val reject : unit -> ('a, 'e) t
          val guard : bool -> (unit, 'e) t
          val on : bool -> (unit, 'e) t -> (unit, 'e) t
          val unless : bool -> (unit, 'e) t -> (unit, 'e) t
          val zero : unit -> ('a, 'e) t
          val plus : ('a, 'e) t -> ('a, 'e) t -> ('a, 'e) t
        end
      type 'a t = 'a list
      type 'a m = 'a
      type 'a e = 'a t
      val lift : '-> 'a e
      val run : 'a e -> 'a e
      val void : 'a e -> unit e
      val sequence : unit e e -> unit e
      val forever : 'a e -> 'b e
      module Fn :
        sig
          val id : '-> 'a e
          val ignore : 'a e -> unit e
          val nothing : unit -> unit e
          val non : ('-> bool e) -> '-> bool e
          val apply_n_times : n:int -> ('-> 'a e) -> '-> 'a e
          val compose : ('-> 'c e) -> ('-> 'b e) -> '-> 'c e
        end
      module Pair :
        sig val fst : ('a * 'b) e -> 'a e val snd : ('a * 'b) e -> 'b e end
      module Triple :
        sig
          val fst : ('a * 'b * 'c) e -> 'a e
          val snd : ('a * 'b * 'c) e -> 'b e
          val trd : ('a * 'b * 'c) e -> 'c e
        end
      module Lift :
        sig
          val nullary : '-> 'a e
          val unary : ('-> 'b) -> 'a e -> 'b e
          val binary : ('-> '-> 'c) -> 'a e -> 'b e -> 'c e
          val ternary :
            ('-> '-> '-> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
          val quaternary :
            ('-> '-> '-> '-> 'e) ->
            'a e -> 'b e -> 'c e -> 'd e -> 'e e
          val quinary :
            ('-> '-> '-> '-> '-> 'f) ->
            'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
        end
      module Exn :
        sig
          val expect :
            ?finally:(unit -> unit e) ->
            f:(unit -> 'a e) -> catch:(exn -> 'a e) -> 'a e
        end
      module Collection :
        sig
          module type S =
            sig
              type 'a t
              val all : 'a e t -> 'a t e
              val all_ignore : 'a e t -> unit e
              val sequence : unit e t -> unit e
              val map : 'a t -> f:('-> 'b e) -> 'b t e
              val iter : 'a t -> f:('-> unit e) -> unit e
              val fold : 'a t -> init:'-> f:('-> '-> 'b e) -> 'b e
              val fold_left : 'a t -> init:'-> f:('-> '-> 'b e) -> 'b e
              val fold_right :
                'a t -> f:('-> '-> 'b e) -> init:'-> 'b e
              val reduce : 'a t -> f:('-> '-> 'a e) -> 'Option.t e
              val exists : 'a t -> f:('-> bool e) -> bool e
              val for_all : 'a t -> f:('-> bool e) -> bool e
              val count : 'a t -> f:('-> bool e) -> int e
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'b t -> f:('-> 'a e) -> 'a e
              val find : 'a t -> f:('-> bool e) -> 'Option.t e
              val find_map : 'a t -> f:('-> 'Option.t e) -> 'Option.t e
              val filter : 'a t -> f:('-> bool e) -> 'a t e
              val filter_map : 'a t -> f:('-> 'Option.t e) -> 'b t e
            end
          module Eager :
            functor (T : Collection.Eager->
              sig
                val all : 'a e T.t -> 'T.t e
                val all_ignore : 'a e T.t -> unit e
                val sequence : unit e T.t -> unit e
                val map : 'T.t -> f:('-> 'b e) -> 'T.t e
                val iter : 'T.t -> f:('-> unit e) -> unit e
                val fold : 'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                val fold_left :
                  'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                val fold_right :
                  'T.t -> f:('-> '-> 'b e) -> init:'-> 'b e
                val reduce : 'T.t -> f:('-> '-> 'a e) -> 'Option.t e
                val exists : 'T.t -> f:('-> bool e) -> bool e
                val for_all : 'T.t -> f:('-> bool e) -> bool e
                val count : 'T.t -> f:('-> bool e) -> int e
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'T.t -> f:('-> 'a e) -> 'a e
                val find : 'T.t -> f:('-> bool e) -> 'Option.t e
                val find_map :
                  'T.t -> f:('-> 'Option.t e) -> 'Option.t e
                val filter : 'T.t -> f:('-> bool e) -> 'T.t e
                val filter_map :
                  'T.t -> f:('-> 'Option.t e) -> 'T.t e
              end
          module Delay :
            functor (T : Collection.Delay->
              sig
                val all : 'a e T.t -> 'T.t e
                val all_ignore : 'a e T.t -> unit e
                val sequence : unit e T.t -> unit e
                val map : 'T.t -> f:('-> 'b e) -> 'T.t e
                val iter : 'T.t -> f:('-> unit e) -> unit e
                val fold : 'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                val fold_left :
                  'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                val fold_right :
                  'T.t -> f:('-> '-> 'b e) -> init:'-> 'b e
                val reduce : 'T.t -> f:('-> '-> 'a e) -> 'Option.t e
                val exists : 'T.t -> f:('-> bool e) -> bool e
                val for_all : 'T.t -> f:('-> bool e) -> bool e
                val count : 'T.t -> f:('-> bool e) -> int e
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'T.t -> f:('-> 'a e) -> 'a e
                val find : 'T.t -> f:('-> bool e) -> 'Option.t e
                val find_map :
                  'T.t -> f:('-> 'Option.t e) -> 'Option.t e
                val filter : 'T.t -> f:('-> bool e) -> 'T.t e
                val filter_map :
                  'T.t -> f:('-> 'Option.t e) -> 'T.t e
              end
        end
      module List :
        sig
          val all : 'a e e -> 'a e e
          val all_ignore : 'a e e -> unit e
          val sequence : unit e e -> unit e
          val map : 'a e -> f:('-> 'b e) -> 'b e e
          val iter : 'a e -> f:('-> unit e) -> unit e
          val fold : 'a e -> init:'-> f:('-> '-> 'b e) -> 'b e
          val fold_left : 'a e -> init:'-> f:('-> '-> 'b e) -> 'b e
          val fold_right : 'a e -> f:('-> '-> 'b e) -> init:'-> 'b e
          val reduce : 'a e -> f:('-> '-> 'a e) -> 'Option.t e
          val exists : 'a e -> f:('-> bool e) -> bool e
          val for_all : 'a e -> f:('-> bool e) -> bool e
          val count : 'a e -> f:('-> bool e) -> int e
          val map_reduce :
            (module Monoid.S with type t = 'a) ->
            'b e -> f:('-> 'a e) -> 'a e
          val find : 'a e -> f:('-> bool e) -> 'Option.t e
          val find_map : 'a e -> f:('-> 'Option.t e) -> 'Option.t e
          val filter : 'a e -> f:('-> bool e) -> 'a e e
          val filter_map : 'a e -> f:('-> 'Option.t e) -> 'b e e
        end
      module Seq :
        sig
          val all :
            'a e Core_kernel.Std.Sequence.t ->
            'Core_kernel.Std.Sequence.t e
          val all_ignore : 'a e Core_kernel.Std.Sequence.t -> unit e
          val sequence : unit e Core_kernel.Std.Sequence.t -> unit e
          val map :
            'Core_kernel.Std.Sequence.t ->
            f:('-> 'b e) -> 'Core_kernel.Std.Sequence.t e
          val iter :
            'Core_kernel.Std.Sequence.t -> f:('-> unit e) -> unit e
          val fold :
            'Core_kernel.Std.Sequence.t ->
            init:'-> f:('-> '-> 'b e) -> 'b e
          val fold_left :
            'Core_kernel.Std.Sequence.t ->
            init:'-> f:('-> '-> 'b e) -> 'b e
          val fold_right :
            'Core_kernel.Std.Sequence.t ->
            f:('-> '-> 'b e) -> init:'-> 'b e
          val reduce :
            'Core_kernel.Std.Sequence.t ->
            f:('-> '-> 'a e) -> 'Option.t e
          val exists :
            'Core_kernel.Std.Sequence.t -> f:('-> bool e) -> bool e
          val for_all :
            'Core_kernel.Std.Sequence.t -> f:('-> bool e) -> bool e
          val count :
            'Core_kernel.Std.Sequence.t -> f:('-> bool e) -> int e
          val map_reduce :
            (module Monoid.S with type t = 'a) ->
            'Core_kernel.Std.Sequence.t -> f:('-> 'a e) -> 'a e
          val find :
            'Core_kernel.Std.Sequence.t ->
            f:('-> bool e) -> 'Option.t e
          val find_map :
            'Core_kernel.Std.Sequence.t ->
            f:('-> 'Option.t e) -> 'Option.t e
          val filter :
            'Core_kernel.Std.Sequence.t ->
            f:('-> bool e) -> 'Core_kernel.Std.Sequence.t e
          val filter_map :
            'Core_kernel.Std.Sequence.t ->
            f:('-> 'Option.t e) -> 'Core_kernel.Std.Sequence.t e
        end
      val ( >=> ) : ('-> 'b e) -> ('-> 'c e) -> '-> 'c e
      val ( !! ) : '-> 'a e
      val ( !$ ) : ('-> 'b) -> 'a e -> 'b e
      val ( !$$ ) : ('-> '-> 'c) -> 'a e -> 'b e -> 'c e
      val ( !$$$ ) : ('-> '-> '-> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
      val ( !$$$$ ) :
        ('-> '-> '-> '-> 'e) -> 'a e -> 'b e -> 'c e -> 'd e -> 'e e
      val ( !$$$$$ ) :
        ('-> '-> '-> '-> '-> 'f) ->
        'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
      val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
      val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
      module Monad_infix :
        sig
          val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
          val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
        end
      val bind : 'a e -> f:('-> 'b e) -> 'b e
      val return : '-> 'a e
      val map : 'a e -> f:('-> 'b) -> 'b e
      val join : 'a e e -> 'a e
      val ignore_m : 'a e -> unit e
      val all : 'a e e -> 'a e e
      val all_ignore : unit e e -> unit e
      module Let_syntax :
        sig
          val return : '-> 'a e
          val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
          val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
          module Let_syntax :
            sig
              val return : '-> 'a e
              val bind : 'a e -> f:('-> 'b e) -> 'b e
              val map : 'a e -> f:('-> 'b) -> 'b e
              val both : 'a e -> 'b e -> ('a * 'b) e
              module Open_on_rhs : sig  end
            end
        end
      module Syntax :
        sig
          val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
          val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
          val ( >=> ) : ('-> 'b e) -> ('-> 'c e) -> '-> 'c e
          val ( !! ) : '-> 'a e
          val ( !$ ) : ('-> 'b) -> 'a e -> 'b e
          val ( !$$ ) : ('-> '-> 'c) -> 'a e -> 'b e -> 'c e
          val ( !$$$ ) :
            ('-> '-> '-> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            'a e -> 'b e -> 'c e -> 'd e -> 'e e
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
        end
      val pure : '-> 'a e
      val accept : '-> 'a e
      val reject : unit -> 'a e
      val guard : bool -> unit e
      val on : bool -> unit e -> unit e
      val unless : bool -> unit e -> unit e
      val zero : unit -> 'a e
      val plus : 'a e -> 'a e -> 'a e
      module T1 :
        functor (M : Core_kernel.Std.T1->
          sig
            type 'a t = 'a list M.t
            type 'a m = 'M.t
            type 'a e = 'Monads.Std.Monad.List.T1.t
          end
      module Make :
        functor (M : Monad->
          sig
            val lift : 'M.t -> 'T1(M).t
            val run : 'T1(M).t -> 'Monads.Std.Monad.List.T1.t
            val void : 'T1(M).t -> unit T1(M).t
            val sequence : unit T1(M).t e -> unit T1(M).t
            val forever : 'T1(M).t -> 'T1(M).t
            module Fn :
              sig
                val id : '-> 'T1(M).t
                val ignore : 'T1(M).t -> unit T1(M).t
                val nothing : unit -> unit T1(M).t
                val non : ('-> bool T1(M).t) -> '-> bool T1(M).t
                val apply_n_times :
                  n:int -> ('-> 'T1(M).t) -> '-> 'T1(M).t
                val compose :
                  ('-> 'T1(M).t) ->
                  ('-> 'T1(M).t) -> '-> 'T1(M).t
              end
            module Pair :
              sig
                val fst : ('a * 'b) T1(M).t -> 'T1(M).t
                val snd : ('a * 'b) T1(M).t -> 'T1(M).t
              end
            module Triple :
              sig
                val fst : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                val snd : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                val trd : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
              end
            module Lift :
              sig
                val nullary : '-> 'T1(M).t
                val unary : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                val binary :
                  ('-> '-> 'c) -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ternary :
                  ('-> '-> '-> 'd) ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val quaternary :
                  ('-> '-> '-> '-> 'e) ->
                  'T1(M).t ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val quinary :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'T1(M).t ->
                  'T1(M).t ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
              end
            module Exn :
              sig
                val expect :
                  ?finally:(unit -> unit T1(M).t) ->
                  f:(unit -> 'T1(M).t) ->
                  catch:(exn -> 'T1(M).t) -> 'T1(M).t
              end
            module Collection :
              sig
                module type S =
                  sig
                    type 'a t
                    val all : 'T1(M).t t -> 'a t T1(M).t
                    val all_ignore : 'T1(M).t t -> unit T1(M).t
                    val sequence : unit T1(M).t t -> unit T1(M).t
                    val map : 'a t -> f:('-> 'T1(M).t) -> 'b t T1(M).t
                    val iter : 'a t -> f:('-> unit T1(M).t) -> unit T1(M).t
                    val fold :
                      'a t ->
                      init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                    val fold_left :
                      'a t ->
                      init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                    val fold_right :
                      'a t ->
                      f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                    val reduce :
                      'a t ->
                      f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                    val exists :
                      'a t -> f:('-> bool T1(M).t) -> bool T1(M).t
                    val for_all :
                      'a t -> f:('-> bool T1(M).t) -> bool T1(M).t
                    val count : 'a t -> f:('-> bool T1(M).t) -> int T1(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b t -> f:('-> 'T1(M).t) -> 'T1(M).t
                    val find :
                      'a t -> f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                    val find_map :
                      'a t ->
                      f:('-> 'Option.t T1(M).t) -> 'Option.t T1(M).t
                    val filter :
                      'a t -> f:('-> bool T1(M).t) -> 'a t T1(M).t
                    val filter_map :
                      'a t -> f:('-> 'Option.t T1(M).t) -> 'b t T1(M).t
                  end
                module Eager :
                  functor (T : Collection.Eager->
                    sig
                      val all : 'T1(M).t T.t -> 'T.t T1(M).t
                      val all_ignore : 'T1(M).t T.t -> unit T1(M).t
                      val sequence : unit T1(M).t T.t -> unit T1(M).t
                      val map :
                        'T.t -> f:('-> 'T1(M).t) -> 'T.t T1(M).t
                      val iter :
                        'T.t -> f:('-> unit T1(M).t) -> unit T1(M).t
                      val fold :
                        'T.t ->
                        init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                      val fold_left :
                        'T.t ->
                        init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                      val reduce :
                        'T.t ->
                        f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                      val exists :
                        'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                      val for_all :
                        'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                      val count :
                        'T.t -> f:('-> bool T1(M).t) -> int T1(M).t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t -> f:('-> 'T1(M).t) -> 'T1(M).t
                      val find :
                        'T.t ->
                        f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                      val find_map :
                        'T.t ->
                        f:('-> 'Option.t T1(M).t) -> 'Option.t T1(M).t
                      val filter :
                        'T.t -> f:('-> bool T1(M).t) -> 'T.t T1(M).t
                      val filter_map :
                        'T.t ->
                        f:('-> 'Option.t T1(M).t) -> 'T.t T1(M).t
                    end
                module Delay :
                  functor (T : Collection.Delay->
                    sig
                      val all : 'T1(M).t T.t -> 'T.t T1(M).t
                      val all_ignore : 'T1(M).t T.t -> unit T1(M).t
                      val sequence : unit T1(M).t T.t -> unit T1(M).t
                      val map :
                        'T.t -> f:('-> 'T1(M).t) -> 'T.t T1(M).t
                      val iter :
                        'T.t -> f:('-> unit T1(M).t) -> unit T1(M).t
                      val fold :
                        'T.t ->
                        init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                      val fold_left :
                        'T.t ->
                        init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                      val reduce :
                        'T.t ->
                        f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                      val exists :
                        'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                      val for_all :
                        'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                      val count :
                        'T.t -> f:('-> bool T1(M).t) -> int T1(M).t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t -> f:('-> 'T1(M).t) -> 'T1(M).t
                      val find :
                        'T.t ->
                        f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                      val find_map :
                        'T.t ->
                        f:('-> 'Option.t T1(M).t) -> 'Option.t T1(M).t
                      val filter :
                        'T.t -> f:('-> bool T1(M).t) -> 'T.t T1(M).t
                      val filter_map :
                        'T.t ->
                        f:('-> 'Option.t T1(M).t) -> 'T.t T1(M).t
                    end
              end
            module List :
              sig
                val all : 'T1(M).t e -> 'a e T1(M).t
                val all_ignore : 'T1(M).t e -> unit T1(M).t
                val sequence : unit T1(M).t e -> unit T1(M).t
                val map : 'a e -> f:('-> 'T1(M).t) -> 'b e T1(M).t
                val iter : 'a e -> f:('-> unit T1(M).t) -> unit T1(M).t
                val fold :
                  'a e -> init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                val fold_left :
                  'a e -> init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                val fold_right :
                  'a e -> f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                val reduce :
                  'a e -> f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                val exists : 'a e -> f:('-> bool T1(M).t) -> bool T1(M).t
                val for_all : 'a e -> f:('-> bool T1(M).t) -> bool T1(M).t
                val count : 'a e -> f:('-> bool T1(M).t) -> int T1(M).t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'b e -> f:('-> 'T1(M).t) -> 'T1(M).t
                val find :
                  'a e -> f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                val find_map :
                  'a e ->
                  f:('-> 'Option.t T1(M).t) -> 'Option.t T1(M).t
                val filter : 'a e -> f:('-> bool T1(M).t) -> 'a e T1(M).t
                val filter_map :
                  'a e -> f:('-> 'Option.t T1(M).t) -> 'b e T1(M).t
              end
            module Seq :
              sig
                val all :
                  'T1(M).t Core_kernel.Std.Sequence.t ->
                  'Core_kernel.Std.Sequence.t T1(M).t
                val all_ignore :
                  'T1(M).t Core_kernel.Std.Sequence.t -> unit T1(M).t
                val sequence :
                  unit T1(M).t Core_kernel.Std.Sequence.t -> unit T1(M).t
                val map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> 'T1(M).t) ->
                  'Core_kernel.Std.Sequence.t T1(M).t
                val iter :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> unit T1(M).t) -> unit T1(M).t
                val fold :
                  'Core_kernel.Std.Sequence.t ->
                  init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                val fold_left :
                  'Core_kernel.Std.Sequence.t ->
                  init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                val fold_right :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                val reduce :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                val exists :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(M).t) -> bool T1(M).t
                val for_all :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(M).t) -> bool T1(M).t
                val count :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(M).t) -> int T1(M).t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> 'T1(M).t) -> 'T1(M).t
                val find :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                val find_map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> 'Option.t T1(M).t) -> 'Option.t T1(M).t
                val filter :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(M).t) ->
                  'Core_kernel.Std.Sequence.t T1(M).t
                val filter_map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> 'Option.t T1(M).t) ->
                  'Core_kernel.Std.Sequence.t T1(M).t
              end
            val ( >=> ) :
              ('-> 'T1(M).t) -> ('-> 'T1(M).t) -> '-> 'T1(M).t
            val ( !! ) : '-> 'T1(M).t
            val ( !$ ) : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
            val ( !$$ ) :
              ('-> '-> 'c) -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
            val ( !$$$ ) :
              ('-> '-> '-> 'd) ->
              'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
            val ( !$$$$ ) :
              ('-> '-> '-> '-> 'e) ->
              'T1(M).t ->
              'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
            val ( !$$$$$ ) :
              ('-> '-> '-> '-> '-> 'f) ->
              'T1(M).t ->
              'T1(M).t ->
              'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
            val ( >>= ) : 'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
            val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
            module Monad_infix :
              sig
                val ( >>= ) : 'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
              end
            val bind : 'T1(M).t -> f:('-> 'T1(M).t) -> 'T1(M).t
            val return : '-> 'T1(M).t
            val map : 'T1(M).t -> f:('-> 'b) -> 'T1(M).t
            val join : 'T1(M).t T1(M).t -> 'T1(M).t
            val ignore_m : 'T1(M).t -> unit T1(M).t
            val all : 'T1(M).t e -> 'a e T1(M).t
            val all_ignore : unit T1(M).t e -> unit T1(M).t
            module Let_syntax :
              sig
                val return : '-> 'T1(M).t
                val ( >>= ) : 'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                module Let_syntax :
                  sig
                    val return : '-> 'T1(M).t
                    val bind :
                      'T1(M).t -> f:('-> 'T1(M).t) -> 'T1(M).t
                    val map : 'T1(M).t -> f:('-> 'b) -> 'T1(M).t
                    val both : 'T1(M).t -> 'T1(M).t -> ('a * 'b) T1(M).t
                    module Open_on_rhs : sig  end
                  end
              end
            module Syntax :
              sig
                val ( >>= ) : 'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                val ( >=> ) :
                  ('-> 'T1(M).t) ->
                  ('-> 'T1(M).t) -> '-> 'T1(M).t
                val ( !! ) : '-> 'T1(M).t
                val ( !$ ) : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  'T1(M).t ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'T1(M).t ->
                  'T1(M).t ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
              end
            val pure : '-> 'T1(M).t
            val accept : '-> 'T1(M).t
            val reject : unit -> 'T1(M).t
            val guard : bool -> unit T1(M).t
            val on : bool -> unit T1(M).t -> unit T1(M).t
            val unless : bool -> unit T1(M).t -> unit T1(M).t
            val zero : unit -> 'T1(M).t
            val plus : 'T1(M).t -> 'T1(M).t -> 'T1(M).t
          end
      module T2 :
        functor (M : Core_kernel.Std.T2->
          sig
            type ('a, 'e) t = ('a list, 'e) M.t
            type ('a, 'e) m = ('a, 'e) M.t
            type ('a, 'e) e = ('a, 'e) Monads.Std.Monad.List.T2.t
          end
      module Make2 :
        functor (M : Monad2->
          sig
            val lift : ('a, 'e) M.t -> ('a, 'e) T2(M).t
            val run : ('a, 'e) T2(M).t -> ('a, 'e) Monads.Std.Monad.List.T2.t
            val void : ('a, 'e) T2(M).t -> (unit, 'e) T2(M).t
            val sequence : (unit, 'e) T2(M).t e -> (unit, 'e) T2(M).t
            val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
            module Fn :
              sig
                val id : '-> ('a, 'e) T2(M).t
                val ignore : ('a, 'e) T2(M).t -> (unit, 'e) T2(M).t
                val nothing : unit -> (unit, 'e) T2(M).t
                val non :
                  ('-> (bool, 'e) T2(M).t) -> '-> (bool, 'e) T2(M).t
                val apply_n_times :
                  n:int -> ('-> ('a, 'e) T2(M).t) -> '-> ('a, 'e) T2(M).t
                val compose :
                  ('-> ('c, 'e) T2(M).t) ->
                  ('-> ('b, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
              end
            module Pair :
              sig
                val fst : ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
                val snd : ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
              end
            module Triple :
              sig
                val fst : ('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
                val snd : ('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
                val trd : ('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
              end
            module Lift :
              sig
                val nullary : '-> ('a, 'e) T2(M).t
                val unary :
                  ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                val binary :
                  ('-> '-> 'c) ->
                  ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                val ternary :
                  ('-> '-> '-> 'd) ->
                  ('a, 'e) T2(M).t ->
                  ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                val quaternary :
                  ('-> '-> '-> '-> 'e) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t -> ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                val quinary :
                  ('-> '-> '-> '-> '-> 'f) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t ->
                  ('d, 's) T2(M).t -> ('e, 's) T2(M).t -> ('f, 's) T2(M).t
              end
            module Exn :
              sig
                val expect :
                  ?finally:(unit -> (unit, 's) T2(M).t) ->
                  f:(unit -> ('a, 's) T2(M).t) ->
                  catch:(exn -> ('a, 's) T2(M).t) -> ('a, 's) T2(M).t
              end
            module Collection :
              sig
                module type S =
                  sig
                    type 'a t
                    val all : ('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
                    val all_ignore : ('a, 'e) T2(M).t t -> (unit, 'e) T2(M).t
                    val sequence : (unit, 'e) T2(M).t t -> (unit, 'e) T2(M).t
                    val map :
                      'a t ->
                      f:('-> ('b, 'e) T2(M).t) -> ('b t, 'e) T2(M).t
                    val iter :
                      'a t ->
                      f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                    val fold :
                      'a t ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_left :
                      'a t ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_right :
                      'a t ->
                      f:('-> '-> ('b, 'e) T2(M).t) ->
                      init:'-> ('b, 'e) T2(M).t
                    val reduce :
                      'a t ->
                      f:('-> '-> ('a, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val exists :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val for_all :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val count :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b t -> f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                    val find :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val find_map :
                      'a t ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val filter :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) -> ('a t, 'e) T2(M).t
                    val filter_map :
                      'a t ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('b t, 'e) T2(M).t
                  end
                module Eager :
                  functor (T : Collection.Eager->
                    sig
                      val all : ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                      val all_ignore :
                        ('a, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                      val sequence :
                        (unit, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                      val map :
                        'T.t ->
                        f:('-> ('b, 'e) T2(M).t) -> ('T.t, 'e) T2(M).t
                      val iter :
                        'T.t ->
                        f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                      val fold :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                      val fold_left :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> ('b, 'e) T2(M).t) ->
                        init:'-> ('b, 'e) T2(M).t
                      val reduce :
                        'T.t ->
                        f:('-> '-> ('a, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val exists :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                      val for_all :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                      val count :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t ->
                        f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                      val find :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val find_map :
                        'T.t ->
                        f:('-> ('Option.t, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val filter :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> ('T.t, 'e) T2(M).t
                      val filter_map :
                        'T.t ->
                        f:('-> ('Option.t, 'e) T2(M).t) ->
                        ('T.t, 'e) T2(M).t
                    end
                module Delay :
                  functor (T : Collection.Delay->
                    sig
                      val all : ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                      val all_ignore :
                        ('a, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                      val sequence :
                        (unit, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                      val map :
                        'T.t ->
                        f:('-> ('b, 'e) T2(M).t) -> ('T.t, 'e) T2(M).t
                      val iter :
                        'T.t ->
                        f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                      val fold :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                      val fold_left :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> ('b, 'e) T2(M).t) ->
                        init:'-> ('b, 'e) T2(M).t
                      val reduce :
                        'T.t ->
                        f:('-> '-> ('a, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val exists :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                      val for_all :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                      val count :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t ->
                        f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                      val find :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val find_map :
                        'T.t ->
                        f:('-> ('Option.t, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val filter :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> ('T.t, 'e) T2(M).t
                      val filter_map :
                        'T.t ->
                        f:('-> ('Option.t, 'e) T2(M).t) ->
                        ('T.t, 'e) T2(M).t
                    end
              end
            module List :
              sig
                val all : ('a, 'e) T2(M).t e -> ('a e, 'e) T2(M).t
                val all_ignore : ('a, 'e) T2(M).t e -> (unit, 'e) T2(M).t
                val sequence : (unit, 'e) T2(M).t e -> (unit, 'e) T2(M).t
                val map :
                  'a e -> f:('-> ('b, 'e) T2(M).t) -> ('b e, 'e) T2(M).t
                val iter :
                  'a e -> f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                val fold :
                  'a e ->
                  init:'->
                  f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val fold_left :
                  'a e ->
                  init:'->
                  f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val fold_right :
                  'a e ->
                  f:('-> '-> ('b, 'e) T2(M).t) ->
                  init:'-> ('b, 'e) T2(M).t
                val reduce :
                  'a e ->
                  f:('-> '-> ('a, 'e) T2(M).t) ->
                  ('Option.t, 'e) T2(M).t
                val exists :
                  'a e -> f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                val for_all :
                  'a e -> f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                val count :
                  'a e -> f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'b e -> f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                val find :
                  'a e ->
                  f:('-> (bool, 'e) T2(M).t) -> ('Option.t, 'e) T2(M).t
                val find_map :
                  'a e ->
                  f:('-> ('Option.t, 'e) T2(M).t) ->
                  ('Option.t, 'e) T2(M).t
                val filter :
                  'a e -> f:('-> (bool, 'e) T2(M).t) -> ('a e, 'e) T2(M).t
                val filter_map :
                  'a e ->
                  f:('-> ('Option.t, 'e) T2(M).t) -> ('b e, 'e) T2(M).t
              end
            module Seq :
              sig
                val all :
                  ('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                  ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                val all_ignore :
                  ('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                  (unit, 'e) T2(M).t
                val sequence :
                  (unit, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                  (unit, 'e) T2(M).t
                val map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> ('b, 'e) T2(M).t) ->
                  ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                val iter :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                val fold :
                  'Core_kernel.Std.Sequence.t ->
                  init:'->
                  f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val fold_left :
                  'Core_kernel.Std.Sequence.t ->
                  init:'->
                  f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val fold_right :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> '-> ('b, 'e) T2(M).t) ->
                  init:'-> ('b, 'e) T2(M).t
                val reduce :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> '-> ('a, 'e) T2(M).t) ->
                  ('Option.t, 'e) T2(M).t
                val exists :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                val for_all :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                val count :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                val find :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) -> ('Option.t, 'e) T2(M).t
                val find_map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> ('Option.t, 'e) T2(M).t) ->
                  ('Option.t, 'e) T2(M).t
                val filter :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) ->
                  ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                val filter_map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> ('Option.t, 'e) T2(M).t) ->
                  ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
              end
            val ( >=> ) :
              ('-> ('b, 'e) T2(M).t) ->
              ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
            val ( !! ) : '-> ('a, 'e) T2(M).t
            val ( !$ ) : ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
            val ( !$$ ) :
              ('-> '-> 'c) ->
              ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
            val ( !$$$ ) :
              ('-> '-> '-> 'd) ->
              ('a, 'e) T2(M).t ->
              ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
            val ( !$$$$ ) :
              ('-> '-> '-> '-> 'e) ->
              ('a, 's) T2(M).t ->
              ('b, 's) T2(M).t ->
              ('c, 's) T2(M).t -> ('d, 's) T2(M).t -> ('e, 's) T2(M).t
            val ( !$$$$$ ) :
              ('-> '-> '-> '-> '-> 'f) ->
              ('a, 's) T2(M).t ->
              ('b, 's) T2(M).t ->
              ('c, 's) T2(M).t ->
              ('d, 's) T2(M).t -> ('e, 's) T2(M).t -> ('f, 's) T2(M).t
            val ( >>= ) :
              ('a, 'e) T2(M).t ->
              ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
            val ( >>| ) : ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
            module Let_syntax :
              sig
                val return : '-> ('a, 'b) T2(M).t
                val ( >>= ) :
                  ('a, 'e) T2(M).t ->
                  ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val ( >>| ) :
                  ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                module Let_syntax :
                  sig
                    val return : '-> ('a, 'b) T2(M).t
                    val bind :
                      ('a, 'e) T2(M).t ->
                      f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val map :
                      ('a, 'e) T2(M).t -> f:('-> 'b) -> ('b, 'e) T2(M).t
                    val both :
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
                    module Open_on_rhs : sig  end
                  end
              end
            module Monad_infix :
              sig
                val ( >>= ) :
                  ('a, 'e) T2(M).t ->
                  ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val ( >>| ) :
                  ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
              end
            val bind :
              ('a, 'e) T2(M).t ->
              f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
            val return : '-> ('a, 'b) T2(M).t
            val map : ('a, 'e) T2(M).t -> f:('-> 'b) -> ('b, 'e) T2(M).t
            val join : (('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
            val ignore_m : ('a, 'e) T2(M).t -> (unit, 'e) T2(M).t
            val all : ('a, 'e) T2(M).t e -> ('a e, 'e) T2(M).t
            val all_ignore : (unit, 'e) T2(M).t e -> (unit, 'e) T2(M).t
            module Syntax :
              sig
                val ( >>= ) :
                  ('a, 'e) T2(M).t ->
                  ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val ( >>| ) :
                  ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                val ( >=> ) :
                  ('-> ('b, 'e) T2(M).t) ->
                  ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                val ( !! ) : '-> ('a, 'e) T2(M).t
                val ( !$ ) :
                  ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) ->
                  ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  ('a, 'e) T2(M).t ->
                  ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t -> ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t ->
                  ('d, 's) T2(M).t -> ('e, 's) T2(M).t -> ('f, 's) T2(M).t
              end
            val pure : '-> ('a, 'e) T2(M).t
            val accept : '-> ('a, 'e) T2(M).t
            val reject : unit -> ('a, 'e) T2(M).t
            val guard : bool -> (unit, 'e) T2(M).t
            val on : bool -> (unit, 'e) T2(M).t -> (unit, 'e) T2(M).t
            val unless : bool -> (unit, 'e) T2(M).t -> (unit, 'e) T2(M).t
            val zero : unit -> ('a, 'e) T2(M).t
            val plus :
              ('a, 'e) T2(M).t -> ('a, 'e) T2(M).t -> ('a, 'e) T2(M).t
          end
    end
  module Seq :
    sig
      module type S =
        sig
          type 'a t
          type 'a m
          type 'a e
          val lift : 'a m -> 'a t
          val run : 'a t -> 'a e
          val void : 'a t -> unit t
          val sequence : unit t List.t -> unit t
          val forever : 'a t -> 'b t
          module Fn :
            sig
              val id : '-> 'a t
              val ignore : 'a t -> unit t
              val nothing : unit -> unit t
              val non : ('-> bool t) -> '-> bool t
              val apply_n_times : n:int -> ('-> 'a t) -> '-> 'a t
              val compose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
            end
          module Pair :
            sig
              val fst : ('a * 'b) t -> 'a t
              val snd : ('a * 'b) t -> 'b t
            end
          module Triple :
            sig
              val fst : ('a * 'b * 'c) t -> 'a t
              val snd : ('a * 'b * 'c) t -> 'b t
              val trd : ('a * 'b * 'c) t -> 'c t
            end
          module Lift :
            sig
              val nullary : '-> 'a t
              val unary : ('-> 'b) -> 'a t -> 'b t
              val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ternary :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val quaternary :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val quinary :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
            end
          module Exn :
            sig
              val expect :
                ?finally:(unit -> unit t) ->
                f:(unit -> 'a t) -> catch:(exn -> 'a t) -> 'a t
            end
          module Collection :
            sig
              module type S =
                sig
                  type 'a t
                  val all : 'a t t -> 'a t t
                  val all_ignore : 'a t t -> unit t
                  val sequence : unit t t -> unit t
                  val map : 'a t -> f:('-> 'b t) -> 'b t t
                  val iter : 'a t -> f:('-> unit t) -> unit t
                  val fold : 'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce : 'a t -> f:('-> '-> 'a t) -> 'Option.t t
                  val exists : 'a t -> f:('-> bool t) -> bool t
                  val for_all : 'a t -> f:('-> bool t) -> bool t
                  val count : 'a t -> f:('-> bool t) -> int t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b t -> f:('-> 'a t) -> 'a t
                  val find : 'a t -> f:('-> bool t) -> 'Option.t t
                  val find_map :
                    'a t -> f:('-> 'Option.t t) -> 'Option.t t
                  val filter : 'a t -> f:('-> bool t) -> 'a t t
                  val filter_map : 'a t -> f:('-> 'Option.t t) -> 'b t t
                end
              module Eager :
                functor (T : Collection.Eager->
                  sig
                    val all : 'a t T.t -> 'T.t t
                    val all_ignore : 'a t T.t -> unit t
                    val sequence : unit t T.t -> unit t
                    val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                    val iter : 'T.t -> f:('-> unit t) -> unit t
                    val fold :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_left :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_right :
                      'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                    val reduce :
                      'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                    val exists : 'T.t -> f:('-> bool t) -> bool t
                    val for_all : 'T.t -> f:('-> bool t) -> bool t
                    val count : 'T.t -> f:('-> bool t) -> int t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> 'a t) -> 'a t
                    val find : 'T.t -> f:('-> bool t) -> 'Option.t t
                    val find_map :
                      'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                    val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                    val filter_map :
                      'T.t -> f:('-> 'Option.t t) -> 'T.t t
                  end
              module Delay :
                functor (T : Collection.Delay->
                  sig
                    val all : 'a t T.t -> 'T.t t
                    val all_ignore : 'a t T.t -> unit t
                    val sequence : unit t T.t -> unit t
                    val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                    val iter : 'T.t -> f:('-> unit t) -> unit t
                    val fold :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_left :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_right :
                      'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                    val reduce :
                      'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                    val exists : 'T.t -> f:('-> bool t) -> bool t
                    val for_all : 'T.t -> f:('-> bool t) -> bool t
                    val count : 'T.t -> f:('-> bool t) -> int t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> 'a t) -> 'a t
                    val find : 'T.t -> f:('-> bool t) -> 'Option.t t
                    val find_map :
                      'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                    val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                    val filter_map :
                      'T.t -> f:('-> 'Option.t t) -> 'T.t t
                  end
            end
          module List :
            sig
              val all : 'a t List.t -> 'List.t t
              val all_ignore : 'a t List.t -> unit t
              val sequence : unit t List.t -> unit t
              val map : 'List.t -> f:('-> 'b t) -> 'List.t t
              val iter : 'List.t -> f:('-> unit t) -> unit t
              val fold : 'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_left :
                'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_right :
                'List.t -> f:('-> '-> 'b t) -> init:'-> 'b t
              val reduce : 'List.t -> f:('-> '-> 'a t) -> 'Option.t t
              val exists : 'List.t -> f:('-> bool t) -> bool t
              val for_all : 'List.t -> f:('-> bool t) -> bool t
              val count : 'List.t -> f:('-> bool t) -> int t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'List.t -> f:('-> 'a t) -> 'a t
              val find : 'List.t -> f:('-> bool t) -> 'Option.t t
              val find_map :
                'List.t -> f:('-> 'Option.t t) -> 'Option.t t
              val filter : 'List.t -> f:('-> bool t) -> 'List.t t
              val filter_map :
                'List.t -> f:('-> 'Option.t t) -> 'List.t t
            end
          module Seq :
            sig
              val all :
                'a t Core_kernel.Std.Sequence.t ->
                'Core_kernel.Std.Sequence.t t
              val all_ignore : 'a t Core_kernel.Std.Sequence.t -> unit t
              val sequence : unit t Core_kernel.Std.Sequence.t -> unit t
              val map :
                'Core_kernel.Std.Sequence.t ->
                f:('-> 'b t) -> 'Core_kernel.Std.Sequence.t t
              val iter :
                'Core_kernel.Std.Sequence.t -> f:('-> unit t) -> unit t
              val fold :
                'Core_kernel.Std.Sequence.t ->
                init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_left :
                'Core_kernel.Std.Sequence.t ->
                init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_right :
                'Core_kernel.Std.Sequence.t ->
                f:('-> '-> 'b t) -> init:'-> 'b t
              val reduce :
                'Core_kernel.Std.Sequence.t ->
                f:('-> '-> 'a t) -> 'Option.t t
              val exists :
                'Core_kernel.Std.Sequence.t -> f:('-> bool t) -> bool t
              val for_all :
                'Core_kernel.Std.Sequence.t -> f:('-> bool t) -> bool t
              val count :
                'Core_kernel.Std.Sequence.t -> f:('-> bool t) -> int t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'Core_kernel.Std.Sequence.t -> f:('-> 'a t) -> 'a t
              val find :
                'Core_kernel.Std.Sequence.t ->
                f:('-> bool t) -> 'Option.t t
              val find_map :
                'Core_kernel.Std.Sequence.t ->
                f:('-> 'Option.t t) -> 'Option.t t
              val filter :
                'Core_kernel.Std.Sequence.t ->
                f:('-> bool t) -> 'Core_kernel.Std.Sequence.t t
              val filter_map :
                'Core_kernel.Std.Sequence.t ->
                f:('-> 'Option.t t) -> 'Core_kernel.Std.Sequence.t t
            end
          val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
          val ( !! ) : '-> 'a t
          val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
          val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
          val ( !$$$ ) :
            ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            'a t -> 'b t -> 'c t -> 'd t -> 'e t
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
          val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
          val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
          module Monad_infix :
            sig
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
            end
          val bind : 'a t -> f:('-> 'b t) -> 'b t
          val return : '-> 'a t
          val map : 'a t -> f:('-> 'b) -> 'b t
          val join : 'a t t -> 'a t
          val ignore_m : 'a t -> unit t
          val all : 'a t list -> 'a list t
          val all_ignore : unit t list -> unit t
          module Let_syntax :
            sig
              val return : '-> 'a t
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              module Let_syntax :
                sig
                  val return : '-> 'a t
                  val bind : 'a t -> f:('-> 'b t) -> 'b t
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val both : 'a t -> 'b t -> ('a * 'b) t
                  module Open_on_rhs : sig  end
                end
            end
          module Syntax :
            sig
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
              val ( !! ) : '-> 'a t
              val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
              val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
            end
          val pure : '-> 'a t
          val accept : '-> 'a t
          val reject : unit -> 'a t
          val guard : bool -> unit t
          val on : bool -> unit t -> unit t
          val unless : bool -> unit t -> unit t
          val zero : unit -> 'a t
          val plus : 'a t -> 'a t -> 'a t
        end
      module type S2 =
        sig
          type ('a, 'e) t
          type ('a, 'e) m
          type ('a, 'e) e
          val lift : ('a, 'e) m -> ('a, 'e) t
          val run : ('a, 'e) t -> ('a, 'e) e
          val void : ('a, 'e) t -> (unit, 'e) t
          val sequence : (unit, 'e) t List.t -> (unit, 'e) t
          val forever : ('a, 'e) t -> ('b, 'e) t
          module Fn :
            sig
              val id : '-> ('a, 'e) t
              val ignore : ('a, 'e) t -> (unit, 'e) t
              val nothing : unit -> (unit, 'e) t
              val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
              val apply_n_times :
                n:int -> ('-> ('a, 'e) t) -> '-> ('a, 'e) t
              val compose :
                ('-> ('c, 'e) t) -> ('-> ('b, 'e) t) -> '-> ('c, 'e) t
            end
          module Pair :
            sig
              val fst : ('a * 'b, 'e) t -> ('a, 'e) t
              val snd : ('a * 'b, 'e) t -> ('b, 'e) t
            end
          module Triple :
            sig
              val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
              val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
              val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
            end
          module Lift :
            sig
              val nullary : '-> ('a, 'e) t
              val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val binary :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ternary :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val quaternary :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val quinary :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
            end
          module Exn :
            sig
              val expect :
                ?finally:(unit -> (unit, 's) t) ->
                f:(unit -> ('a, 's) t) ->
                catch:(exn -> ('a, 's) t) -> ('a, 's) t
            end
          module Collection :
            sig
              module type S =
                sig
                  type 'a t
                  val all : ('a, 'e) t t -> ('a t, 'e) t
                  val all_ignore : ('a, 'e) t t -> (unit, 'e) t
                  val sequence : (unit, 'e) t t -> (unit, 'e) t
                  val map : 'a t -> f:('-> ('b, 'e) t) -> ('b t, 'e) t
                  val iter : 'a t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                  val fold :
                    'a t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'a t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'a t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'a t -> f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                  val exists : 'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count : 'a t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'a t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                  val find_map :
                    'a t ->
                    f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                  val filter : 'a t -> f:('-> (bool, 'e) t) -> ('a t, 'e) t
                  val filter_map :
                    'a t -> f:('-> ('Option.t, 'e) t) -> ('b t, 'e) t
                end
              module Eager :
                functor (T : Collection.Eager->
                  sig
                    val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                    val all_ignore : ('a, 'e) t T.t -> (unit, 'e) t
                    val sequence : (unit, 'e) t T.t -> (unit, 'e) t
                    val map :
                      'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                    val iter :
                      'T.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                    val fold :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_left :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_right :
                      'T.t ->
                      f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                    val reduce :
                      'T.t ->
                      f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                    val exists :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val for_all :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val count :
                      'T.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                    val find :
                      'T.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                    val find_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                    val filter :
                      'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                    val filter_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                  end
              module Delay :
                functor (T : Collection.Delay->
                  sig
                    val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                    val all_ignore : ('a, 'e) t T.t -> (unit, 'e) t
                    val sequence : (unit, 'e) t T.t -> (unit, 'e) t
                    val map :
                      'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                    val iter :
                      'T.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                    val fold :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_left :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_right :
                      'T.t ->
                      f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                    val reduce :
                      'T.t ->
                      f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                    val exists :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val for_all :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val count :
                      'T.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                    val find :
                      'T.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                    val find_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                    val filter :
                      'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                    val filter_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                  end
            end
          module List :
            sig
              val all : ('a, 'e) t List.t -> ('List.t, 'e) t
              val all_ignore : ('a, 'e) t List.t -> (unit, 'e) t
              val sequence : (unit, 'e) t List.t -> (unit, 'e) t
              val map :
                'List.t -> f:('-> ('b, 'e) t) -> ('List.t, 'e) t
              val iter : 'List.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
              val fold :
                'List.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_left :
                'List.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_right :
                'List.t ->
                f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
              val reduce :
                'List.t ->
                f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
              val exists :
                'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val for_all :
                'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val count : 'List.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'List.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
              val find :
                'List.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
              val find_map :
                'List.t ->
                f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
              val filter :
                'List.t -> f:('-> (bool, 'e) t) -> ('List.t, 'e) t
              val filter_map :
                'List.t ->
                f:('-> ('Option.t, 'e) t) -> ('List.t, 'e) t
            end
          module Seq :
            sig
              val all :
                ('a, 'e) t Core_kernel.Std.Sequence.t ->
                ('Core_kernel.Std.Sequence.t, 'e) t
              val all_ignore :
                ('a, 'e) t Core_kernel.Std.Sequence.t -> (unit, 'e) t
              val sequence :
                (unit, 'e) t Core_kernel.Std.Sequence.t -> (unit, 'e) t
              val map :
                'Core_kernel.Std.Sequence.t ->
                f:('-> ('b, 'e) t) -> ('Core_kernel.Std.Sequence.t, 'e) t
              val iter :
                'Core_kernel.Std.Sequence.t ->
                f:('-> (unit, 'e) t) -> (unit, 'e) t
              val fold :
                'Core_kernel.Std.Sequence.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_left :
                'Core_kernel.Std.Sequence.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_right :
                'Core_kernel.Std.Sequence.t ->
                f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
              val reduce :
                'Core_kernel.Std.Sequence.t ->
                f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
              val exists :
                'Core_kernel.Std.Sequence.t ->
                f:('-> (bool, 'e) t) -> (bool, 'e) t
              val for_all :
                'Core_kernel.Std.Sequence.t ->
                f:('-> (bool, 'e) t) -> (bool, 'e) t
              val count :
                'Core_kernel.Std.Sequence.t ->
                f:('-> (bool, 'e) t) -> (int, 'e) t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'Core_kernel.Std.Sequence.t ->
                f:('-> ('a, 'e) t) -> ('a, 'e) t
              val find :
                'Core_kernel.Std.Sequence.t ->
                f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
              val find_map :
                'Core_kernel.Std.Sequence.t ->
                f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
              val filter :
                'Core_kernel.Std.Sequence.t ->
                f:('-> (bool, 'e) t) ->
                ('Core_kernel.Std.Sequence.t, 'e) t
              val filter_map :
                'Core_kernel.Std.Sequence.t ->
                f:('-> ('Option.t, 'e) t) ->
                ('Core_kernel.Std.Sequence.t, 'e) t
            end
          val ( >=> ) :
            ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
          val ( !! ) : '-> ('a, 'e) t
          val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
          val ( !$$ ) :
            ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
          val ( !$$$ ) :
            ('-> '-> '-> 'd) ->
            ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            ('a, 's) t ->
            ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            ('a, 's) t ->
            ('b, 's) t ->
            ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
          val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
          val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
          module Let_syntax :
            sig
              val return : '-> ('a, 'b) t
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              module Let_syntax :
                sig
                  val return : '-> ('a, 'b) t
                  val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                  val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                  val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                  module Open_on_rhs : sig  end
                end
            end
          module Monad_infix :
            sig
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
            end
          val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
          val return : '-> ('a, 'b) t
          val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
          val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
          val ignore_m : ('a, 'e) t -> (unit, 'e) t
          val all : ('a, 'e) t list -> ('a list, 'e) t
          val all_ignore : (unit, 'e) t list -> (unit, 'e) t
          module Syntax :
            sig
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              val ( >=> ) :
                ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
              val ( !! ) : '-> ('a, 'e) t
              val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val ( !$$ ) :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
            end
          val pure : '-> ('a, 'e) t
          val accept : '-> ('a, 'e) t
          val reject : unit -> ('a, 'e) t
          val guard : bool -> (unit, 'e) t
          val on : bool -> (unit, 'e) t -> (unit, 'e) t
          val unless : bool -> (unit, 'e) t -> (unit, 'e) t
          val zero : unit -> ('a, 'e) t
          val plus : ('a, 'e) t -> ('a, 'e) t -> ('a, 'e) t
        end
      type 'a t = 'Core_kernel.Std.Sequence.t
      type 'a m = 'a
      type 'a e = 'a t
      val lift : '-> 'a e
      val run : 'a e -> 'a e
      val void : 'a e -> unit e
      val sequence : unit e List.t -> unit e
      val forever : 'a e -> 'b e
      module Fn :
        sig
          val id : '-> 'a e
          val ignore : 'a e -> unit e
          val nothing : unit -> unit e
          val non : ('-> bool e) -> '-> bool e
          val apply_n_times : n:int -> ('-> 'a e) -> '-> 'a e
          val compose : ('-> 'c e) -> ('-> 'b e) -> '-> 'c e
        end
      module Pair :
        sig val fst : ('a * 'b) e -> 'a e val snd : ('a * 'b) e -> 'b e end
      module Triple :
        sig
          val fst : ('a * 'b * 'c) e -> 'a e
          val snd : ('a * 'b * 'c) e -> 'b e
          val trd : ('a * 'b * 'c) e -> 'c e
        end
      module Lift :
        sig
          val nullary : '-> 'a e
          val unary : ('-> 'b) -> 'a e -> 'b e
          val binary : ('-> '-> 'c) -> 'a e -> 'b e -> 'c e
          val ternary :
            ('-> '-> '-> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
          val quaternary :
            ('-> '-> '-> '-> 'e) ->
            'a e -> 'b e -> 'c e -> 'd e -> 'e e
          val quinary :
            ('-> '-> '-> '-> '-> 'f) ->
            'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
        end
      module Exn :
        sig
          val expect :
            ?finally:(unit -> unit e) ->
            f:(unit -> 'a e) -> catch:(exn -> 'a e) -> 'a e
        end
      module Collection :
        sig
          module type S =
            sig
              type 'a t
              val all : 'a e t -> 'a t e
              val all_ignore : 'a e t -> unit e
              val sequence : unit e t -> unit e
              val map : 'a t -> f:('-> 'b e) -> 'b t e
              val iter : 'a t -> f:('-> unit e) -> unit e
              val fold : 'a t -> init:'-> f:('-> '-> 'b e) -> 'b e
              val fold_left : 'a t -> init:'-> f:('-> '-> 'b e) -> 'b e
              val fold_right :
                'a t -> f:('-> '-> 'b e) -> init:'-> 'b e
              val reduce : 'a t -> f:('-> '-> 'a e) -> 'Option.t e
              val exists : 'a t -> f:('-> bool e) -> bool e
              val for_all : 'a t -> f:('-> bool e) -> bool e
              val count : 'a t -> f:('-> bool e) -> int e
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'b t -> f:('-> 'a e) -> 'a e
              val find : 'a t -> f:('-> bool e) -> 'Option.t e
              val find_map : 'a t -> f:('-> 'Option.t e) -> 'Option.t e
              val filter : 'a t -> f:('-> bool e) -> 'a t e
              val filter_map : 'a t -> f:('-> 'Option.t e) -> 'b t e
            end
          module Eager :
            functor (T : Collection.Eager->
              sig
                val all : 'a e T.t -> 'T.t e
                val all_ignore : 'a e T.t -> unit e
                val sequence : unit e T.t -> unit e
                val map : 'T.t -> f:('-> 'b e) -> 'T.t e
                val iter : 'T.t -> f:('-> unit e) -> unit e
                val fold : 'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                val fold_left :
                  'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                val fold_right :
                  'T.t -> f:('-> '-> 'b e) -> init:'-> 'b e
                val reduce : 'T.t -> f:('-> '-> 'a e) -> 'Option.t e
                val exists : 'T.t -> f:('-> bool e) -> bool e
                val for_all : 'T.t -> f:('-> bool e) -> bool e
                val count : 'T.t -> f:('-> bool e) -> int e
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'T.t -> f:('-> 'a e) -> 'a e
                val find : 'T.t -> f:('-> bool e) -> 'Option.t e
                val find_map :
                  'T.t -> f:('-> 'Option.t e) -> 'Option.t e
                val filter : 'T.t -> f:('-> bool e) -> 'T.t e
                val filter_map :
                  'T.t -> f:('-> 'Option.t e) -> 'T.t e
              end
          module Delay :
            functor (T : Collection.Delay->
              sig
                val all : 'a e T.t -> 'T.t e
                val all_ignore : 'a e T.t -> unit e
                val sequence : unit e T.t -> unit e
                val map : 'T.t -> f:('-> 'b e) -> 'T.t e
                val iter : 'T.t -> f:('-> unit e) -> unit e
                val fold : 'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                val fold_left :
                  'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                val fold_right :
                  'T.t -> f:('-> '-> 'b e) -> init:'-> 'b e
                val reduce : 'T.t -> f:('-> '-> 'a e) -> 'Option.t e
                val exists : 'T.t -> f:('-> bool e) -> bool e
                val for_all : 'T.t -> f:('-> bool e) -> bool e
                val count : 'T.t -> f:('-> bool e) -> int e
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'T.t -> f:('-> 'a e) -> 'a e
                val find : 'T.t -> f:('-> bool e) -> 'Option.t e
                val find_map :
                  'T.t -> f:('-> 'Option.t e) -> 'Option.t e
                val filter : 'T.t -> f:('-> bool e) -> 'T.t e
                val filter_map :
                  'T.t -> f:('-> 'Option.t e) -> 'T.t e
              end
        end
      module List :
        sig
          val all : 'a e List.t -> 'List.t e
          val all_ignore : 'a e List.t -> unit e
          val sequence : unit e List.t -> unit e
          val map : 'List.t -> f:('-> 'b e) -> 'List.t e
          val iter : 'List.t -> f:('-> unit e) -> unit e
          val fold : 'List.t -> init:'-> f:('-> '-> 'b e) -> 'b e
          val fold_left :
            'List.t -> init:'-> f:('-> '-> 'b e) -> 'b e
          val fold_right :
            'List.t -> f:('-> '-> 'b e) -> init:'-> 'b e
          val reduce : 'List.t -> f:('-> '-> 'a e) -> 'Option.t e
          val exists : 'List.t -> f:('-> bool e) -> bool e
          val for_all : 'List.t -> f:('-> bool e) -> bool e
          val count : 'List.t -> f:('-> bool e) -> int e
          val map_reduce :
            (module Monoid.S with type t = 'a) ->
            'List.t -> f:('-> 'a e) -> 'a e
          val find : 'List.t -> f:('-> bool e) -> 'Option.t e
          val find_map :
            'List.t -> f:('-> 'Option.t e) -> 'Option.t e
          val filter : 'List.t -> f:('-> bool e) -> 'List.t e
          val filter_map :
            'List.t -> f:('-> 'Option.t e) -> 'List.t e
        end
      module Seq :
        sig
          val all : 'a e e -> 'a e e
          val all_ignore : 'a e e -> unit e
          val sequence : unit e e -> unit e
          val map : 'a e -> f:('-> 'b e) -> 'b e e
          val iter : 'a e -> f:('-> unit e) -> unit e
          val fold : 'a e -> init:'-> f:('-> '-> 'b e) -> 'b e
          val fold_left : 'a e -> init:'-> f:('-> '-> 'b e) -> 'b e
          val fold_right : 'a e -> f:('-> '-> 'b e) -> init:'-> 'b e
          val reduce : 'a e -> f:('-> '-> 'a e) -> 'Option.t e
          val exists : 'a e -> f:('-> bool e) -> bool e
          val for_all : 'a e -> f:('-> bool e) -> bool e
          val count : 'a e -> f:('-> bool e) -> int e
          val map_reduce :
            (module Monoid.S with type t = 'a) ->
            'b e -> f:('-> 'a e) -> 'a e
          val find : 'a e -> f:('-> bool e) -> 'Option.t e
          val find_map : 'a e -> f:('-> 'Option.t e) -> 'Option.t e
          val filter : 'a e -> f:('-> bool e) -> 'a e e
          val filter_map : 'a e -> f:('-> 'Option.t e) -> 'b e e
        end
      val ( >=> ) : ('-> 'b e) -> ('-> 'c e) -> '-> 'c e
      val ( !! ) : '-> 'a e
      val ( !$ ) : ('-> 'b) -> 'a e -> 'b e
      val ( !$$ ) : ('-> '-> 'c) -> 'a e -> 'b e -> 'c e
      val ( !$$$ ) : ('-> '-> '-> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
      val ( !$$$$ ) :
        ('-> '-> '-> '-> 'e) -> 'a e -> 'b e -> 'c e -> 'd e -> 'e e
      val ( !$$$$$ ) :
        ('-> '-> '-> '-> '-> 'f) ->
        'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
      val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
      val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
      module Monad_infix :
        sig
          val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
          val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
        end
      val bind : 'a e -> f:('-> 'b e) -> 'b e
      val return : '-> 'a e
      val map : 'a e -> f:('-> 'b) -> 'b e
      val join : 'a e e -> 'a e
      val ignore_m : 'a e -> unit e
      val all : 'a e list -> 'a list e
      val all_ignore : unit e list -> unit e
      module Let_syntax :
        sig
          val return : '-> 'a e
          val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
          val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
          module Let_syntax :
            sig
              val return : '-> 'a e
              val bind : 'a e -> f:('-> 'b e) -> 'b e
              val map : 'a e -> f:('-> 'b) -> 'b e
              val both : 'a e -> 'b e -> ('a * 'b) e
              module Open_on_rhs : sig  end
            end
        end
      module Syntax :
        sig
          val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
          val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
          val ( >=> ) : ('-> 'b e) -> ('-> 'c e) -> '-> 'c e
          val ( !! ) : '-> 'a e
          val ( !$ ) : ('-> 'b) -> 'a e -> 'b e
          val ( !$$ ) : ('-> '-> 'c) -> 'a e -> 'b e -> 'c e
          val ( !$$$ ) :
            ('-> '-> '-> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            'a e -> 'b e -> 'c e -> 'd e -> 'e e
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
        end
      val pure : '-> 'a e
      val accept : '-> 'a e
      val reject : unit -> 'a e
      val guard : bool -> unit e
      val on : bool -> unit e -> unit e
      val unless : bool -> unit e -> unit e
      val zero : unit -> 'a e
      val plus : 'a e -> 'a e -> 'a e
      module T1 :
        functor (M : Core_kernel.Std.T1->
          sig
            type 'a t = 'Core_kernel.Std.Sequence.t M.t
            type 'a m = 'M.t
            type 'a e = 'Monads.Std.Monad.Seq.T1.t
          end
      module Make :
        functor (M : Monad->
          sig
            val lift : 'M.t -> 'T1(M).t
            val run : 'T1(M).t -> 'Monads.Std.Monad.Seq.T1.t
            val void : 'T1(M).t -> unit T1(M).t
            val sequence : unit T1(M).t list -> unit T1(M).t
            val forever : 'T1(M).t -> 'T1(M).t
            module Fn :
              sig
                val id : '-> 'T1(M).t
                val ignore : 'T1(M).t -> unit T1(M).t
                val nothing : unit -> unit T1(M).t
                val non : ('-> bool T1(M).t) -> '-> bool T1(M).t
                val apply_n_times :
                  n:int -> ('-> 'T1(M).t) -> '-> 'T1(M).t
                val compose :
                  ('-> 'T1(M).t) ->
                  ('-> 'T1(M).t) -> '-> 'T1(M).t
              end
            module Pair :
              sig
                val fst : ('a * 'b) T1(M).t -> 'T1(M).t
                val snd : ('a * 'b) T1(M).t -> 'T1(M).t
              end
            module Triple :
              sig
                val fst : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                val snd : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                val trd : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
              end
            module Lift :
              sig
                val nullary : '-> 'T1(M).t
                val unary : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                val binary :
                  ('-> '-> 'c) -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ternary :
                  ('-> '-> '-> 'd) ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val quaternary :
                  ('-> '-> '-> '-> 'e) ->
                  'T1(M).t ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val quinary :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'T1(M).t ->
                  'T1(M).t ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
              end
            module Exn :
              sig
                val expect :
                  ?finally:(unit -> unit T1(M).t) ->
                  f:(unit -> 'T1(M).t) ->
                  catch:(exn -> 'T1(M).t) -> 'T1(M).t
              end
            module Collection :
              sig
                module type S =
                  sig
                    type 'a t
                    val all : 'T1(M).t t -> 'a t T1(M).t
                    val all_ignore : 'T1(M).t t -> unit T1(M).t
                    val sequence : unit T1(M).t t -> unit T1(M).t
                    val map : 'a t -> f:('-> 'T1(M).t) -> 'b t T1(M).t
                    val iter : 'a t -> f:('-> unit T1(M).t) -> unit T1(M).t
                    val fold :
                      'a t ->
                      init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                    val fold_left :
                      'a t ->
                      init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                    val fold_right :
                      'a t ->
                      f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                    val reduce :
                      'a t ->
                      f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                    val exists :
                      'a t -> f:('-> bool T1(M).t) -> bool T1(M).t
                    val for_all :
                      'a t -> f:('-> bool T1(M).t) -> bool T1(M).t
                    val count : 'a t -> f:('-> bool T1(M).t) -> int T1(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b t -> f:('-> 'T1(M).t) -> 'T1(M).t
                    val find :
                      'a t -> f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                    val find_map :
                      'a t ->
                      f:('-> 'Option.t T1(M).t) -> 'Option.t T1(M).t
                    val filter :
                      'a t -> f:('-> bool T1(M).t) -> 'a t T1(M).t
                    val filter_map :
                      'a t -> f:('-> 'Option.t T1(M).t) -> 'b t T1(M).t
                  end
                module Eager :
                  functor (T : Collection.Eager->
                    sig
                      val all : 'T1(M).t T.t -> 'T.t T1(M).t
                      val all_ignore : 'T1(M).t T.t -> unit T1(M).t
                      val sequence : unit T1(M).t T.t -> unit T1(M).t
                      val map :
                        'T.t -> f:('-> 'T1(M).t) -> 'T.t T1(M).t
                      val iter :
                        'T.t -> f:('-> unit T1(M).t) -> unit T1(M).t
                      val fold :
                        'T.t ->
                        init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                      val fold_left :
                        'T.t ->
                        init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                      val reduce :
                        'T.t ->
                        f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                      val exists :
                        'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                      val for_all :
                        'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                      val count :
                        'T.t -> f:('-> bool T1(M).t) -> int T1(M).t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t -> f:('-> 'T1(M).t) -> 'T1(M).t
                      val find :
                        'T.t ->
                        f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                      val find_map :
                        'T.t ->
                        f:('-> 'Option.t T1(M).t) -> 'Option.t T1(M).t
                      val filter :
                        'T.t -> f:('-> bool T1(M).t) -> 'T.t T1(M).t
                      val filter_map :
                        'T.t ->
                        f:('-> 'Option.t T1(M).t) -> 'T.t T1(M).t
                    end
                module Delay :
                  functor (T : Collection.Delay->
                    sig
                      val all : 'T1(M).t T.t -> 'T.t T1(M).t
                      val all_ignore : 'T1(M).t T.t -> unit T1(M).t
                      val sequence : unit T1(M).t T.t -> unit T1(M).t
                      val map :
                        'T.t -> f:('-> 'T1(M).t) -> 'T.t T1(M).t
                      val iter :
                        'T.t -> f:('-> unit T1(M).t) -> unit T1(M).t
                      val fold :
                        'T.t ->
                        init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                      val fold_left :
                        'T.t ->
                        init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                      val reduce :
                        'T.t ->
                        f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                      val exists :
                        'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                      val for_all :
                        'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                      val count :
                        'T.t -> f:('-> bool T1(M).t) -> int T1(M).t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t -> f:('-> 'T1(M).t) -> 'T1(M).t
                      val find :
                        'T.t ->
                        f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                      val find_map :
                        'T.t ->
                        f:('-> 'Option.t T1(M).t) -> 'Option.t T1(M).t
                      val filter :
                        'T.t -> f:('-> bool T1(M).t) -> 'T.t T1(M).t
                      val filter_map :
                        'T.t ->
                        f:('-> 'Option.t T1(M).t) -> 'T.t T1(M).t
                    end
              end
            module List :
              sig
                val all : 'T1(M).t list -> 'a list T1(M).t
                val all_ignore : 'T1(M).t list -> unit T1(M).t
                val sequence : unit T1(M).t list -> unit T1(M).t
                val map : 'a list -> f:('-> 'T1(M).t) -> 'b list T1(M).t
                val iter : 'a list -> f:('-> unit T1(M).t) -> unit T1(M).t
                val fold :
                  'a list ->
                  init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                val fold_left :
                  'a list ->
                  init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                val fold_right :
                  'a list ->
                  f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                val reduce :
                  'a list ->
                  f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                val exists :
                  'a list -> f:('-> bool T1(M).t) -> bool T1(M).t
                val for_all :
                  'a list -> f:('-> bool T1(M).t) -> bool T1(M).t
                val count : 'a list -> f:('-> bool T1(M).t) -> int T1(M).t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'b list -> f:('-> 'T1(M).t) -> 'T1(M).t
                val find :
                  'a list -> f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                val find_map :
                  'a list ->
                  f:('-> 'Option.t T1(M).t) -> 'Option.t T1(M).t
                val filter :
                  'a list -> f:('-> bool T1(M).t) -> 'a list T1(M).t
                val filter_map :
                  'a list -> f:('-> 'Option.t T1(M).t) -> 'b list T1(M).t
              end
            module Seq :
              sig
                val all : 'T1(M).t e -> 'a e T1(M).t
                val all_ignore : 'T1(M).t e -> unit T1(M).t
                val sequence : unit T1(M).t e -> unit T1(M).t
                val map : 'a e -> f:('-> 'T1(M).t) -> 'b e T1(M).t
                val iter : 'a e -> f:('-> unit T1(M).t) -> unit T1(M).t
                val fold :
                  'a e -> init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                val fold_left :
                  'a e -> init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                val fold_right :
                  'a e -> f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                val reduce :
                  'a e -> f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                val exists : 'a e -> f:('-> bool T1(M).t) -> bool T1(M).t
                val for_all : 'a e -> f:('-> bool T1(M).t) -> bool T1(M).t
                val count : 'a e -> f:('-> bool T1(M).t) -> int T1(M).t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'b e -> f:('-> 'T1(M).t) -> 'T1(M).t
                val find :
                  'a e -> f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                val find_map :
                  'a e ->
                  f:('-> 'Option.t T1(M).t) -> 'Option.t T1(M).t
                val filter : 'a e -> f:('-> bool T1(M).t) -> 'a e T1(M).t
                val filter_map :
                  'a e -> f:('-> 'Option.t T1(M).t) -> 'b e T1(M).t
              end
            val ( >=> ) :
              ('-> 'T1(M).t) -> ('-> 'T1(M).t) -> '-> 'T1(M).t
            val ( !! ) : '-> 'T1(M).t
            val ( !$ ) : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
            val ( !$$ ) :
              ('-> '-> 'c) -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
            val ( !$$$ ) :
              ('-> '-> '-> 'd) ->
              'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
            val ( !$$$$ ) :
              ('-> '-> '-> '-> 'e) ->
              'T1(M).t ->
              'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
            val ( !$$$$$ ) :
              ('-> '-> '-> '-> '-> 'f) ->
              'T1(M).t ->
              'T1(M).t ->
              'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
            val ( >>= ) : 'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
            val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
            module Monad_infix :
              sig
                val ( >>= ) : 'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
              end
            val bind : 'T1(M).t -> f:('-> 'T1(M).t) -> 'T1(M).t
            val return : '-> 'T1(M).t
            val map : 'T1(M).t -> f:('-> 'b) -> 'T1(M).t
            val join : 'T1(M).t T1(M).t -> 'T1(M).t
            val ignore_m : 'T1(M).t -> unit T1(M).t
            val all : 'T1(M).t list -> 'a list T1(M).t
            val all_ignore : unit T1(M).t list -> unit T1(M).t
            module Let_syntax :
              sig
                val return : '-> 'T1(M).t
                val ( >>= ) : 'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                module Let_syntax :
                  sig
                    val return : '-> 'T1(M).t
                    val bind :
                      'T1(M).t -> f:('-> 'T1(M).t) -> 'T1(M).t
                    val map : 'T1(M).t -> f:('-> 'b) -> 'T1(M).t
                    val both : 'T1(M).t -> 'T1(M).t -> ('a * 'b) T1(M).t
                    module Open_on_rhs : sig  end
                  end
              end
            module Syntax :
              sig
                val ( >>= ) : 'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                val ( >=> ) :
                  ('-> 'T1(M).t) ->
                  ('-> 'T1(M).t) -> '-> 'T1(M).t
                val ( !! ) : '-> 'T1(M).t
                val ( !$ ) : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  'T1(M).t ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'T1(M).t ->
                  'T1(M).t ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
              end
            val pure : '-> 'T1(M).t
            val accept : '-> 'T1(M).t
            val reject : unit -> 'T1(M).t
            val guard : bool -> unit T1(M).t
            val on : bool -> unit T1(M).t -> unit T1(M).t
            val unless : bool -> unit T1(M).t -> unit T1(M).t
            val zero : unit -> 'T1(M).t
            val plus : 'T1(M).t -> 'T1(M).t -> 'T1(M).t
          end
      module T2 :
        functor (M : Core_kernel.Std.T2->
          sig
            type ('a, 'e) t = ('Core_kernel.Std.Sequence.t, 'e) M.t
            type ('a, 'e) m = ('a, 'e) M.t
            type ('a, 'e) e = ('a, 'e) Monads.Std.Monad.Seq.T2.t
          end
      module Make2 :
        functor (M : Monad2->
          sig
            val lift : ('a, 'e) M.t -> ('a, 'e) T2(M).t
            val run : ('a, 'e) T2(M).t -> ('a, 'e) Monads.Std.Monad.Seq.T2.t
            val void : ('a, 'e) T2(M).t -> (unit, 'e) T2(M).t
            val sequence : (unit, 'e) T2(M).t list -> (unit, 'e) T2(M).t
            val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
            module Fn :
              sig
                val id : '-> ('a, 'e) T2(M).t
                val ignore : ('a, 'e) T2(M).t -> (unit, 'e) T2(M).t
                val nothing : unit -> (unit, 'e) T2(M).t
                val non :
                  ('-> (bool, 'e) T2(M).t) -> '-> (bool, 'e) T2(M).t
                val apply_n_times :
                  n:int -> ('-> ('a, 'e) T2(M).t) -> '-> ('a, 'e) T2(M).t
                val compose :
                  ('-> ('c, 'e) T2(M).t) ->
                  ('-> ('b, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
              end
            module Pair :
              sig
                val fst : ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
                val snd : ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
              end
            module Triple :
              sig
                val fst : ('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
                val snd : ('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
                val trd : ('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
              end
            module Lift :
              sig
                val nullary : '-> ('a, 'e) T2(M).t
                val unary :
                  ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                val binary :
                  ('-> '-> 'c) ->
                  ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                val ternary :
                  ('-> '-> '-> 'd) ->
                  ('a, 'e) T2(M).t ->
                  ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                val quaternary :
                  ('-> '-> '-> '-> 'e) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t -> ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                val quinary :
                  ('-> '-> '-> '-> '-> 'f) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t ->
                  ('d, 's) T2(M).t -> ('e, 's) T2(M).t -> ('f, 's) T2(M).t
              end
            module Exn :
              sig
                val expect :
                  ?finally:(unit -> (unit, 's) T2(M).t) ->
                  f:(unit -> ('a, 's) T2(M).t) ->
                  catch:(exn -> ('a, 's) T2(M).t) -> ('a, 's) T2(M).t
              end
            module Collection :
              sig
                module type S =
                  sig
                    type 'a t
                    val all : ('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
                    val all_ignore : ('a, 'e) T2(M).t t -> (unit, 'e) T2(M).t
                    val sequence : (unit, 'e) T2(M).t t -> (unit, 'e) T2(M).t
                    val map :
                      'a t ->
                      f:('-> ('b, 'e) T2(M).t) -> ('b t, 'e) T2(M).t
                    val iter :
                      'a t ->
                      f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                    val fold :
                      'a t ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_left :
                      'a t ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_right :
                      'a t ->
                      f:('-> '-> ('b, 'e) T2(M).t) ->
                      init:'-> ('b, 'e) T2(M).t
                    val reduce :
                      'a t ->
                      f:('-> '-> ('a, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val exists :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val for_all :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val count :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b t -> f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                    val find :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val find_map :
                      'a t ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val filter :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) -> ('a t, 'e) T2(M).t
                    val filter_map :
                      'a t ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('b t, 'e) T2(M).t
                  end
                module Eager :
                  functor (T : Collection.Eager->
                    sig
                      val all : ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                      val all_ignore :
                        ('a, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                      val sequence :
                        (unit, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                      val map :
                        'T.t ->
                        f:('-> ('b, 'e) T2(M).t) -> ('T.t, 'e) T2(M).t
                      val iter :
                        'T.t ->
                        f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                      val fold :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                      val fold_left :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> ('b, 'e) T2(M).t) ->
                        init:'-> ('b, 'e) T2(M).t
                      val reduce :
                        'T.t ->
                        f:('-> '-> ('a, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val exists :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                      val for_all :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                      val count :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t ->
                        f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                      val find :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val find_map :
                        'T.t ->
                        f:('-> ('Option.t, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val filter :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> ('T.t, 'e) T2(M).t
                      val filter_map :
                        'T.t ->
                        f:('-> ('Option.t, 'e) T2(M).t) ->
                        ('T.t, 'e) T2(M).t
                    end
                module Delay :
                  functor (T : Collection.Delay->
                    sig
                      val all : ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                      val all_ignore :
                        ('a, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                      val sequence :
                        (unit, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                      val map :
                        'T.t ->
                        f:('-> ('b, 'e) T2(M).t) -> ('T.t, 'e) T2(M).t
                      val iter :
                        'T.t ->
                        f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                      val fold :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                      val fold_left :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> ('b, 'e) T2(M).t) ->
                        init:'-> ('b, 'e) T2(M).t
                      val reduce :
                        'T.t ->
                        f:('-> '-> ('a, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val exists :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                      val for_all :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                      val count :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t ->
                        f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                      val find :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val find_map :
                        'T.t ->
                        f:('-> ('Option.t, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val filter :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> ('T.t, 'e) T2(M).t
                      val filter_map :
                        'T.t ->
                        f:('-> ('Option.t, 'e) T2(M).t) ->
                        ('T.t, 'e) T2(M).t
                    end
              end
            module List :
              sig
                val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                val all_ignore : ('a, 'e) T2(M).t list -> (unit, 'e) T2(M).t
                val sequence : (unit, 'e) T2(M).t list -> (unit, 'e) T2(M).t
                val map :
                  'a list ->
                  f:('-> ('b, 'e) T2(M).t) -> ('b list, 'e) T2(M).t
                val iter :
                  'a list ->
                  f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                val fold :
                  'a list ->
                  init:'->
                  f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val fold_left :
                  'a list ->
                  init:'->
                  f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val fold_right :
                  'a list ->
                  f:('-> '-> ('b, 'e) T2(M).t) ->
                  init:'-> ('b, 'e) T2(M).t
                val reduce :
                  'a list ->
                  f:('-> '-> ('a, 'e) T2(M).t) ->
                  ('Option.t, 'e) T2(M).t
                val exists :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                val for_all :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                val count :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'b list -> f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                val find :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> ('Option.t, 'e) T2(M).t
                val find_map :
                  'a list ->
                  f:('-> ('Option.t, 'e) T2(M).t) ->
                  ('Option.t, 'e) T2(M).t
                val filter :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> ('a list, 'e) T2(M).t
                val filter_map :
                  'a list ->
                  f:('-> ('Option.t, 'e) T2(M).t) ->
                  ('b list, 'e) T2(M).t
              end
            module Seq :
              sig
                val all : ('a, 'e) T2(M).t e -> ('a e, 'e) T2(M).t
                val all_ignore : ('a, 'e) T2(M).t e -> (unit, 'e) T2(M).t
                val sequence : (unit, 'e) T2(M).t e -> (unit, 'e) T2(M).t
                val map :
                  'a e -> f:('-> ('b, 'e) T2(M).t) -> ('b e, 'e) T2(M).t
                val iter :
                  'a e -> f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                val fold :
                  'a e ->
                  init:'->
                  f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val fold_left :
                  'a e ->
                  init:'->
                  f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val fold_right :
                  'a e ->
                  f:('-> '-> ('b, 'e) T2(M).t) ->
                  init:'-> ('b, 'e) T2(M).t
                val reduce :
                  'a e ->
                  f:('-> '-> ('a, 'e) T2(M).t) ->
                  ('Option.t, 'e) T2(M).t
                val exists :
                  'a e -> f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                val for_all :
                  'a e -> f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                val count :
                  'a e -> f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'b e -> f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                val find :
                  'a e ->
                  f:('-> (bool, 'e) T2(M).t) -> ('Option.t, 'e) T2(M).t
                val find_map :
                  'a e ->
                  f:('-> ('Option.t, 'e) T2(M).t) ->
                  ('Option.t, 'e) T2(M).t
                val filter :
                  'a e -> f:('-> (bool, 'e) T2(M).t) -> ('a e, 'e) T2(M).t
                val filter_map :
                  'a e ->
                  f:('-> ('Option.t, 'e) T2(M).t) -> ('b e, 'e) T2(M).t
              end
            val ( >=> ) :
              ('-> ('b, 'e) T2(M).t) ->
              ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
            val ( !! ) : '-> ('a, 'e) T2(M).t
            val ( !$ ) : ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
            val ( !$$ ) :
              ('-> '-> 'c) ->
              ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
            val ( !$$$ ) :
              ('-> '-> '-> 'd) ->
              ('a, 'e) T2(M).t ->
              ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
            val ( !$$$$ ) :
              ('-> '-> '-> '-> 'e) ->
              ('a, 's) T2(M).t ->
              ('b, 's) T2(M).t ->
              ('c, 's) T2(M).t -> ('d, 's) T2(M).t -> ('e, 's) T2(M).t
            val ( !$$$$$ ) :
              ('-> '-> '-> '-> '-> 'f) ->
              ('a, 's) T2(M).t ->
              ('b, 's) T2(M).t ->
              ('c, 's) T2(M).t ->
              ('d, 's) T2(M).t -> ('e, 's) T2(M).t -> ('f, 's) T2(M).t
            val ( >>= ) :
              ('a, 'e) T2(M).t ->
              ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
            val ( >>| ) : ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
            module Let_syntax :
              sig
                val return : '-> ('a, 'b) T2(M).t
                val ( >>= ) :
                  ('a, 'e) T2(M).t ->
                  ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val ( >>| ) :
                  ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                module Let_syntax :
                  sig
                    val return : '-> ('a, 'b) T2(M).t
                    val bind :
                      ('a, 'e) T2(M).t ->
                      f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val map :
                      ('a, 'e) T2(M).t -> f:('-> 'b) -> ('b, 'e) T2(M).t
                    val both :
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
                    module Open_on_rhs : sig  end
                  end
              end
            module Monad_infix :
              sig
                val ( >>= ) :
                  ('a, 'e) T2(M).t ->
                  ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val ( >>| ) :
                  ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
              end
            val bind :
              ('a, 'e) T2(M).t ->
              f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
            val return : '-> ('a, 'b) T2(M).t
            val map : ('a, 'e) T2(M).t -> f:('-> 'b) -> ('b, 'e) T2(M).t
            val join : (('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
            val ignore_m : ('a, 'e) T2(M).t -> (unit, 'e) T2(M).t
            val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
            val all_ignore : (unit, 'e) T2(M).t list -> (unit, 'e) T2(M).t
            module Syntax :
              sig
                val ( >>= ) :
                  ('a, 'e) T2(M).t ->
                  ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val ( >>| ) :
                  ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                val ( >=> ) :
                  ('-> ('b, 'e) T2(M).t) ->
                  ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                val ( !! ) : '-> ('a, 'e) T2(M).t
                val ( !$ ) :
                  ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) ->
                  ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  ('a, 'e) T2(M).t ->
                  ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t -> ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t ->
                  ('d, 's) T2(M).t -> ('e, 's) T2(M).t -> ('f, 's) T2(M).t
              end
            val pure : '-> ('a, 'e) T2(M).t
            val accept : '-> ('a, 'e) T2(M).t
            val reject : unit -> ('a, 'e) T2(M).t
            val guard : bool -> (unit, 'e) T2(M).t
            val on : bool -> (unit, 'e) T2(M).t -> (unit, 'e) T2(M).t
            val unless : bool -> (unit, 'e) T2(M).t -> (unit, 'e) T2(M).t
            val zero : unit -> ('a, 'e) T2(M).t
            val plus :
              ('a, 'e) T2(M).t -> ('a, 'e) T2(M).t -> ('a, 'e) T2(M).t
          end
    end
  module Writer :
    sig
      module type S =
        sig
          type state
          type 'a t
          type 'a m
          type 'a e
          val lift : 'a m -> 'a t
          val run : 'a t -> 'a e
          val write : Monads.Std.Monad.Writer.S.state -> unit t
          val read : 'a t -> Monads.Std.Monad.Writer.S.state t
          val listen : 'a t -> ('a * Monads.Std.Monad.Writer.S.state) t
          val exec : unit t -> Monads.Std.Monad.Writer.S.state m
          val void : 'a t -> unit t
          val sequence : unit t List.t -> unit t
          val forever : 'a t -> 'b t
          module Fn :
            sig
              val id : '-> 'a t
              val ignore : 'a t -> unit t
              val nothing : unit -> unit t
              val non : ('-> bool t) -> '-> bool t
              val apply_n_times : n:int -> ('-> 'a t) -> '-> 'a t
              val compose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
            end
          module Pair :
            sig
              val fst : ('a * 'b) t -> 'a t
              val snd : ('a * 'b) t -> 'b t
            end
          module Triple :
            sig
              val fst : ('a * 'b * 'c) t -> 'a t
              val snd : ('a * 'b * 'c) t -> 'b t
              val trd : ('a * 'b * 'c) t -> 'c t
            end
          module Lift :
            sig
              val nullary : '-> 'a t
              val unary : ('-> 'b) -> 'a t -> 'b t
              val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ternary :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val quaternary :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val quinary :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
            end
          module Exn :
            sig
              val expect :
                ?finally:(unit -> unit t) ->
                f:(unit -> 'a t) -> catch:(exn -> 'a t) -> 'a t
            end
          module Collection :
            sig
              module type S =
                sig
                  type 'a t
                  val all : 'a t t -> 'a t t
                  val all_ignore : 'a t t -> unit t
                  val sequence : unit t t -> unit t
                  val map : 'a t -> f:('-> 'b t) -> 'b t t
                  val iter : 'a t -> f:('-> unit t) -> unit t
                  val fold : 'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce : 'a t -> f:('-> '-> 'a t) -> 'Option.t t
                  val exists : 'a t -> f:('-> bool t) -> bool t
                  val for_all : 'a t -> f:('-> bool t) -> bool t
                  val count : 'a t -> f:('-> bool t) -> int t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b t -> f:('-> 'a t) -> 'a t
                  val find : 'a t -> f:('-> bool t) -> 'Option.t t
                  val find_map :
                    'a t -> f:('-> 'Option.t t) -> 'Option.t t
                  val filter : 'a t -> f:('-> bool t) -> 'a t t
                  val filter_map : 'a t -> f:('-> 'Option.t t) -> 'b t t
                end
              module Eager :
                functor (T : Collection.Eager->
                  sig
                    val all : 'a t T.t -> 'T.t t
                    val all_ignore : 'a t T.t -> unit t
                    val sequence : unit t T.t -> unit t
                    val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                    val iter : 'T.t -> f:('-> unit t) -> unit t
                    val fold :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_left :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_right :
                      'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                    val reduce :
                      'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                    val exists : 'T.t -> f:('-> bool t) -> bool t
                    val for_all : 'T.t -> f:('-> bool t) -> bool t
                    val count : 'T.t -> f:('-> bool t) -> int t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> 'a t) -> 'a t
                    val find : 'T.t -> f:('-> bool t) -> 'Option.t t
                    val find_map :
                      'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                    val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                    val filter_map :
                      'T.t -> f:('-> 'Option.t t) -> 'T.t t
                  end
              module Delay :
                functor (T : Collection.Delay->
                  sig
                    val all : 'a t T.t -> 'T.t t
                    val all_ignore : 'a t T.t -> unit t
                    val sequence : unit t T.t -> unit t
                    val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                    val iter : 'T.t -> f:('-> unit t) -> unit t
                    val fold :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_left :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_right :
                      'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                    val reduce :
                      'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                    val exists : 'T.t -> f:('-> bool t) -> bool t
                    val for_all : 'T.t -> f:('-> bool t) -> bool t
                    val count : 'T.t -> f:('-> bool t) -> int t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> 'a t) -> 'a t
                    val find : 'T.t -> f:('-> bool t) -> 'Option.t t
                    val find_map :
                      'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                    val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                    val filter_map :
                      'T.t -> f:('-> 'Option.t t) -> 'T.t t
                  end
            end
          module List :
            sig
              val all : 'a t List.t -> 'List.t t
              val all_ignore : 'a t List.t -> unit t
              val sequence : unit t List.t -> unit t
              val map : 'List.t -> f:('-> 'b t) -> 'List.t t
              val iter : 'List.t -> f:('-> unit t) -> unit t
              val fold : 'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_left :
                'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_right :
                'List.t -> f:('-> '-> 'b t) -> init:'-> 'b t
              val reduce : 'List.t -> f:('-> '-> 'a t) -> 'Option.t t
              val exists : 'List.t -> f:('-> bool t) -> bool t
              val for_all : 'List.t -> f:('-> bool t) -> bool t
              val count : 'List.t -> f:('-> bool t) -> int t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'List.t -> f:('-> 'a t) -> 'a t
              val find : 'List.t -> f:('-> bool t) -> 'Option.t t
              val find_map :
                'List.t -> f:('-> 'Option.t t) -> 'Option.t t
              val filter : 'List.t -> f:('-> bool t) -> 'List.t t
              val filter_map :
                'List.t -> f:('-> 'Option.t t) -> 'List.t t
            end
          module Seq :
            sig
              val all : 'a t Seq.t -> 'Seq.t t
              val all_ignore : 'a t Seq.t -> unit t
              val sequence : unit t Seq.t -> unit t
              val map : 'Seq.t -> f:('-> 'b t) -> 'Seq.t t
              val iter : 'Seq.t -> f:('-> unit t) -> unit t
              val fold : 'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_left :
                'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_right :
                'Seq.t -> f:('-> '-> 'b t) -> init:'-> 'b t
              val reduce : 'Seq.t -> f:('-> '-> 'a t) -> 'Option.t t
              val exists : 'Seq.t -> f:('-> bool t) -> bool t
              val for_all : 'Seq.t -> f:('-> bool t) -> bool t
              val count : 'Seq.t -> f:('-> bool t) -> int t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'Seq.t -> f:('-> 'a t) -> 'a t
              val find : 'Seq.t -> f:('-> bool t) -> 'Option.t t
              val find_map :
                'Seq.t -> f:('-> 'Option.t t) -> 'Option.t t
              val filter : 'Seq.t -> f:('-> bool t) -> 'Seq.t t
              val filter_map :
                'Seq.t -> f:('-> 'Option.t t) -> 'Seq.t t
            end
          val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
          val ( !! ) : '-> 'a t
          val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
          val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
          val ( !$$$ ) :
            ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            'a t -> 'b t -> 'c t -> 'd t -> 'e t
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
          val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
          val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
          module Monad_infix :
            sig
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
            end
          val bind : 'a t -> f:('-> 'b t) -> 'b t
          val return : '-> 'a t
          val map : 'a t -> f:('-> 'b) -> 'b t
          val join : 'a t t -> 'a t
          val ignore_m : 'a t -> unit t
          val all : 'a t list -> 'a list t
          val all_ignore : unit t list -> unit t
          module Let_syntax :
            sig
              val return : '-> 'a t
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              module Let_syntax :
                sig
                  val return : '-> 'a t
                  val bind : 'a t -> f:('-> 'b t) -> 'b t
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val both : 'a t -> 'b t -> ('a * 'b) t
                  module Open_on_rhs : sig  end
                end
            end
          module Syntax :
            sig
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
              val ( !! ) : '-> 'a t
              val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
              val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
            end
        end
      type ('a, 'b) writer
      module T1 :
        functor (T : Monoid.S) (M : Monad->
          sig
            type state = T.t
            type 'a m = 'M.t
            type 'a t =
                ('a, Monads.Std.Monad.Writer.T1.state)
                Monads.Std.Monad.Writer.writer Monads.Std.Monad.Writer.T1.m
            type 'a e =
                ('a * Monads.Std.Monad.Writer.T1.state)
                Monads.Std.Monad.Writer.T1.m
          end
      module Make :
        functor (T : Monoid.S) (M : Monad->
          sig
            val lift : 'M.t -> 'T1(T)(M).t
            val run : 'T1(T)(M).t -> 'T1(T)(M).e
            val write : T.t -> unit T1(T)(M).t
            val read : 'T1(T)(M).t -> T.t T1(T)(M).t
            val listen : 'T1(T)(M).t -> ('a * T.t) T1(T)(M).t
            val exec : unit T1(T)(M).t -> T.t M.t
            val void : 'T1(T)(M).t -> unit T1(T)(M).t
            val sequence : unit T1(T)(M).t List.t -> unit T1(T)(M).t
            val forever : 'T1(T)(M).t -> 'T1(T)(M).t
            module Fn :
              sig
                val id : '-> 'T1(T)(M).t
                val ignore : 'T1(T)(M).t -> unit T1(T)(M).t
                val nothing : unit -> unit T1(T)(M).t
                val non : ('-> bool T1(T)(M).t) -> '-> bool T1(T)(M).t
                val apply_n_times :
                  n:int -> ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                val compose :
                  ('-> 'T1(T)(M).t) ->
                  ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
              end
            module Pair :
              sig
                val fst : ('a * 'b) T1(T)(M).t -> 'T1(T)(M).t
                val snd : ('a * 'b) T1(T)(M).t -> 'T1(T)(M).t
              end
            module Triple :
              sig
                val fst : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                val snd : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                val trd : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
              end
            module Lift :
              sig
                val nullary : '-> 'T1(T)(M).t
                val unary : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                val binary :
                  ('-> '-> 'c) ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ternary :
                  ('-> '-> '-> 'd) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val quaternary :
                  ('-> '-> '-> '-> 'e) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val quinary :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
              end
            module Exn :
              sig
                val expect :
                  ?finally:(unit -> unit T1(T)(M).t) ->
                  f:(unit -> 'T1(T)(M).t) ->
                  catch:(exn -> 'T1(T)(M).t) -> 'T1(T)(M).t
              end
            module Collection :
              sig
                module type S =
                  sig
                    type 'a t
                    val all : 'T1(T)(M).t t -> 'a t T1(T)(M).t
                    val all_ignore : 'T1(T)(M).t t -> unit T1(T)(M).t
                    val sequence : unit T1(T)(M).t t -> unit T1(T)(M).t
                    val map :
                      'a t -> f:('-> 'T1(T)(M).t) -> 'b t T1(T)(M).t
                    val iter :
                      'a t -> f:('-> unit T1(T)(M).t) -> unit T1(T)(M).t
                    val fold :
                      'a t ->
                      init:'->
                      f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val fold_left :
                      'a t ->
                      init:'->
                      f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val fold_right :
                      'a t ->
                      f:('-> '-> 'T1(T)(M).t) ->
                      init:'-> 'T1(T)(M).t
                    val reduce :
                      'a t ->
                      f:('-> '-> 'T1(T)(M).t) -> 'Option.t T1(T)(M).t
                    val exists :
                      'a t -> f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                    val for_all :
                      'a t -> f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                    val count :
                      'a t -> f:('-> bool T1(T)(M).t) -> int T1(T)(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b t -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val find :
                      'a t ->
                      f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                    val find_map :
                      'a t ->
                      f:('-> 'Option.t T1(T)(M).t) ->
                      'Option.t T1(T)(M).t
                    val filter :
                      'a t -> f:('-> bool T1(T)(M).t) -> 'a t T1(T)(M).t
                    val filter_map :
                      'a t ->
                      f:('-> 'Option.t T1(T)(M).t) -> 'b t T1(T)(M).t
                  end
                module Eager :
                  functor (T : Collection.Eager->
                    sig
                      val all : 'T1(T)(M).t T.t -> 'T.t T1(T)(M).t
                      val all_ignore : 'T1(T)(M).t T.t -> unit T1(T)(M).t
                      val sequence : unit T1(T)(M).t T.t -> unit T1(T)(M).t
                      val map :
                        'T.t ->
                        f:('-> 'T1(T)(M).t) -> 'T.t T1(T)(M).t
                      val iter :
                        'T.t ->
                        f:('-> unit T1(T)(M).t) -> unit T1(T)(M).t
                      val fold :
                        'T.t ->
                        init:'->
                        f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                      val fold_left :
                        'T.t ->
                        init:'->
                        f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> 'T1(T)(M).t) ->
                        init:'-> 'T1(T)(M).t
                      val reduce :
                        'T.t ->
                        f:('-> '-> 'T1(T)(M).t) ->
                        'Option.t T1(T)(M).t
                      val exists :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                      val for_all :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                      val count :
                        'T.t -> f:('-> bool T1(T)(M).t) -> int T1(T)(M).t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                      val find :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                      val find_map :
                        'T.t ->
                        f:('-> 'Option.t T1(T)(M).t) ->
                        'Option.t T1(T)(M).t
                      val filter :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> 'T.t T1(T)(M).t
                      val filter_map :
                        'T.t ->
                        f:('-> 'Option.t T1(T)(M).t) -> 'T.t T1(T)(M).t
                    end
                module Delay :
                  functor (T : Collection.Delay->
                    sig
                      val all : 'T1(T)(M).t T.t -> 'T.t T1(T)(M).t
                      val all_ignore : 'T1(T)(M).t T.t -> unit T1(T)(M).t
                      val sequence : unit T1(T)(M).t T.t -> unit T1(T)(M).t
                      val map :
                        'T.t ->
                        f:('-> 'T1(T)(M).t) -> 'T.t T1(T)(M).t
                      val iter :
                        'T.t ->
                        f:('-> unit T1(T)(M).t) -> unit T1(T)(M).t
                      val fold :
                        'T.t ->
                        init:'->
                        f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                      val fold_left :
                        'T.t ->
                        init:'->
                        f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> 'T1(T)(M).t) ->
                        init:'-> 'T1(T)(M).t
                      val reduce :
                        'T.t ->
                        f:('-> '-> 'T1(T)(M).t) ->
                        'Option.t T1(T)(M).t
                      val exists :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                      val for_all :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                      val count :
                        'T.t -> f:('-> bool T1(T)(M).t) -> int T1(T)(M).t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                      val find :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                      val find_map :
                        'T.t ->
                        f:('-> 'Option.t T1(T)(M).t) ->
                        'Option.t T1(T)(M).t
                      val filter :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> 'T.t T1(T)(M).t
                      val filter_map :
                        'T.t ->
                        f:('-> 'Option.t T1(T)(M).t) -> 'T.t T1(T)(M).t
                    end
              end
            module List :
              sig
                val all : 'T1(T)(M).t List.t -> 'List.t T1(T)(M).t
                val all_ignore : 'T1(T)(M).t List.t -> unit T1(T)(M).t
                val sequence : unit T1(T)(M).t List.t -> unit T1(T)(M).t
                val map :
                  'List.t ->
                  f:('-> 'T1(T)(M).t) -> 'List.t T1(T)(M).t
                val iter :
                  'List.t -> f:('-> unit T1(T)(M).t) -> unit T1(T)(M).t
                val fold :
                  'List.t ->
                  init:'-> f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val fold_left :
                  'List.t ->
                  init:'-> f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val fold_right :
                  'List.t ->
                  f:('-> '-> 'T1(T)(M).t) -> init:'-> 'T1(T)(M).t
                val reduce :
                  'List.t ->
                  f:('-> '-> 'T1(T)(M).t) -> 'Option.t T1(T)(M).t
                val exists :
                  'List.t -> f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                val for_all :
                  'List.t -> f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                val count :
                  'List.t -> f:('-> bool T1(T)(M).t) -> int T1(T)(M).t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'List.t -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val find :
                  'List.t ->
                  f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                val find_map :
                  'List.t ->
                  f:('-> 'Option.t T1(T)(M).t) -> 'Option.t T1(T)(M).t
                val filter :
                  'List.t ->
                  f:('-> bool T1(T)(M).t) -> 'List.t T1(T)(M).t
                val filter_map :
                  'List.t ->
                  f:('-> 'Option.t T1(T)(M).t) -> 'List.t T1(T)(M).t
              end
            module Seq :
              sig
                val all : 'T1(T)(M).t Seq.t -> 'Seq.t T1(T)(M).t
                val all_ignore : 'T1(T)(M).t Seq.t -> unit T1(T)(M).t
                val sequence : unit T1(T)(M).t Seq.t -> unit T1(T)(M).t
                val map :
                  'Seq.t -> f:('-> 'T1(T)(M).t) -> 'Seq.t T1(T)(M).t
                val iter :
                  'Seq.t -> f:('-> unit T1(T)(M).t) -> unit T1(T)(M).t
                val fold :
                  'Seq.t ->
                  init:'-> f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val fold_left :
                  'Seq.t ->
                  init:'-> f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val fold_right :
                  'Seq.t ->
                  f:('-> '-> 'T1(T)(M).t) -> init:'-> 'T1(T)(M).t
                val reduce :
                  'Seq.t ->
                  f:('-> '-> 'T1(T)(M).t) -> 'Option.t T1(T)(M).t
                val exists :
                  'Seq.t -> f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                val for_all :
                  'Seq.t -> f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                val count :
                  'Seq.t -> f:('-> bool T1(T)(M).t) -> int T1(T)(M).t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'Seq.t -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val find :
                  'Seq.t ->
                  f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                val find_map :
                  'Seq.t ->
                  f:('-> 'Option.t T1(T)(M).t) -> 'Option.t T1(T)(M).t
                val filter :
                  'Seq.t ->
                  f:('-> bool T1(T)(M).t) -> 'Seq.t T1(T)(M).t
                val filter_map :
                  'Seq.t ->
                  f:('-> 'Option.t T1(T)(M).t) -> 'Seq.t T1(T)(M).t
              end
            val ( >=> ) :
              ('-> 'T1(T)(M).t) ->
              ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
            val ( !! ) : '-> 'T1(T)(M).t
            val ( !$ ) : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
            val ( !$$ ) :
              ('-> '-> 'c) ->
              'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
            val ( !$$$ ) :
              ('-> '-> '-> 'd) ->
              'T1(T)(M).t ->
              'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
            val ( !$$$$ ) :
              ('-> '-> '-> '-> 'e) ->
              'T1(T)(M).t ->
              'T1(T)(M).t ->
              'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
            val ( !$$$$$ ) :
              ('-> '-> '-> '-> '-> 'f) ->
              'T1(T)(M).t ->
              'T1(T)(M).t ->
              'T1(T)(M).t ->
              'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
            val ( >>= ) :
              'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
            val ( >>| ) : 'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
            module Monad_infix :
              sig
                val ( >>= ) :
                  'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val ( >>| ) : 'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
              end
            val bind :
              'T1(T)(M).t -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
            val return : '-> 'T1(T)(M).t
            val map : 'T1(T)(M).t -> f:('-> 'b) -> 'T1(T)(M).t
            val join : 'T1(T)(M).t T1(T)(M).t -> 'T1(T)(M).t
            val ignore_m : 'T1(T)(M).t -> unit T1(T)(M).t
            val all : 'T1(T)(M).t list -> 'a list T1(T)(M).t
            val all_ignore : unit T1(T)(M).t list -> unit T1(T)(M).t
            module Let_syntax :
              sig
                val return : '-> 'T1(T)(M).t
                val ( >>= ) :
                  'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val ( >>| ) : 'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                module Let_syntax :
                  sig
                    val return : '-> 'T1(T)(M).t
                    val bind :
                      'T1(T)(M).t ->
                      f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val map : 'T1(T)(M).t -> f:('-> 'b) -> 'T1(T)(M).t
                    val both :
                      'T1(T)(M).t -> 'T1(T)(M).t -> ('a * 'b) T1(T)(M).t
                    module Open_on_rhs : sig  end
                  end
              end
            module Syntax :
              sig
                val ( >>= ) :
                  'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val ( >>| ) : 'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                val ( >=> ) :
                  ('-> 'T1(T)(M).t) ->
                  ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                val ( !! ) : '-> 'T1(T)(M).t
                val ( !$ ) : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
              end
          end
    end
  module Reader :
    sig
      module type S =
        sig
          type 'a t
          type 'a m
          type 'a e
          val lift : 'a m -> 'a t
          val run : 'a t -> 'a e
          type env
          val read : unit -> Monads.Std.Monad.Reader.S.env t
          val void : 'a t -> unit t
          val sequence : unit t List.t -> unit t
          val forever : 'a t -> 'b t
          module Fn :
            sig
              val id : '-> 'a t
              val ignore : 'a t -> unit t
              val nothing : unit -> unit t
              val non : ('-> bool t) -> '-> bool t
              val apply_n_times : n:int -> ('-> 'a t) -> '-> 'a t
              val compose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
            end
          module Pair :
            sig
              val fst : ('a * 'b) t -> 'a t
              val snd : ('a * 'b) t -> 'b t
            end
          module Triple :
            sig
              val fst : ('a * 'b * 'c) t -> 'a t
              val snd : ('a * 'b * 'c) t -> 'b t
              val trd : ('a * 'b * 'c) t -> 'c t
            end
          module Lift :
            sig
              val nullary : '-> 'a t
              val unary : ('-> 'b) -> 'a t -> 'b t
              val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ternary :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val quaternary :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val quinary :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
            end
          module Exn :
            sig
              val expect :
                ?finally:(unit -> unit t) ->
                f:(unit -> 'a t) -> catch:(exn -> 'a t) -> 'a t
            end
          module Collection :
            sig
              module type S =
                sig
                  type 'a t
                  val all : 'a t t -> 'a t t
                  val all_ignore : 'a t t -> unit t
                  val sequence : unit t t -> unit t
                  val map : 'a t -> f:('-> 'b t) -> 'b t t
                  val iter : 'a t -> f:('-> unit t) -> unit t
                  val fold : 'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce : 'a t -> f:('-> '-> 'a t) -> 'Option.t t
                  val exists : 'a t -> f:('-> bool t) -> bool t
                  val for_all : 'a t -> f:('-> bool t) -> bool t
                  val count : 'a t -> f:('-> bool t) -> int t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b t -> f:('-> 'a t) -> 'a t
                  val find : 'a t -> f:('-> bool t) -> 'Option.t t
                  val find_map :
                    'a t -> f:('-> 'Option.t t) -> 'Option.t t
                  val filter : 'a t -> f:('-> bool t) -> 'a t t
                  val filter_map : 'a t -> f:('-> 'Option.t t) -> 'b t t
                end
              module Eager :
                functor (T : Collection.Eager->
                  sig
                    val all : 'a t T.t -> 'T.t t
                    val all_ignore : 'a t T.t -> unit t
                    val sequence : unit t T.t -> unit t
                    val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                    val iter : 'T.t -> f:('-> unit t) -> unit t
                    val fold :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_left :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_right :
                      'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                    val reduce :
                      'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                    val exists : 'T.t -> f:('-> bool t) -> bool t
                    val for_all : 'T.t -> f:('-> bool t) -> bool t
                    val count : 'T.t -> f:('-> bool t) -> int t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> 'a t) -> 'a t
                    val find : 'T.t -> f:('-> bool t) -> 'Option.t t
                    val find_map :
                      'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                    val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                    val filter_map :
                      'T.t -> f:('-> 'Option.t t) -> 'T.t t
                  end
              module Delay :
                functor (T : Collection.Delay->
                  sig
                    val all : 'a t T.t -> 'T.t t
                    val all_ignore : 'a t T.t -> unit t
                    val sequence : unit t T.t -> unit t
                    val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                    val iter : 'T.t -> f:('-> unit t) -> unit t
                    val fold :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_left :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_right :
                      'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                    val reduce :
                      'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                    val exists : 'T.t -> f:('-> bool t) -> bool t
                    val for_all : 'T.t -> f:('-> bool t) -> bool t
                    val count : 'T.t -> f:('-> bool t) -> int t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> 'a t) -> 'a t
                    val find : 'T.t -> f:('-> bool t) -> 'Option.t t
                    val find_map :
                      'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                    val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                    val filter_map :
                      'T.t -> f:('-> 'Option.t t) -> 'T.t t
                  end
            end
          module List :
            sig
              val all : 'a t List.t -> 'List.t t
              val all_ignore : 'a t List.t -> unit t
              val sequence : unit t List.t -> unit t
              val map : 'List.t -> f:('-> 'b t) -> 'List.t t
              val iter : 'List.t -> f:('-> unit t) -> unit t
              val fold : 'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_left :
                'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_right :
                'List.t -> f:('-> '-> 'b t) -> init:'-> 'b t
              val reduce : 'List.t -> f:('-> '-> 'a t) -> 'Option.t t
              val exists : 'List.t -> f:('-> bool t) -> bool t
              val for_all : 'List.t -> f:('-> bool t) -> bool t
              val count : 'List.t -> f:('-> bool t) -> int t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'List.t -> f:('-> 'a t) -> 'a t
              val find : 'List.t -> f:('-> bool t) -> 'Option.t t
              val find_map :
                'List.t -> f:('-> 'Option.t t) -> 'Option.t t
              val filter : 'List.t -> f:('-> bool t) -> 'List.t t
              val filter_map :
                'List.t -> f:('-> 'Option.t t) -> 'List.t t
            end
          module Seq :
            sig
              val all : 'a t Seq.t -> 'Seq.t t
              val all_ignore : 'a t Seq.t -> unit t
              val sequence : unit t Seq.t -> unit t
              val map : 'Seq.t -> f:('-> 'b t) -> 'Seq.t t
              val iter : 'Seq.t -> f:('-> unit t) -> unit t
              val fold : 'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_left :
                'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_right :
                'Seq.t -> f:('-> '-> 'b t) -> init:'-> 'b t
              val reduce : 'Seq.t -> f:('-> '-> 'a t) -> 'Option.t t
              val exists : 'Seq.t -> f:('-> bool t) -> bool t
              val for_all : 'Seq.t -> f:('-> bool t) -> bool t
              val count : 'Seq.t -> f:('-> bool t) -> int t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'Seq.t -> f:('-> 'a t) -> 'a t
              val find : 'Seq.t -> f:('-> bool t) -> 'Option.t t
              val find_map :
                'Seq.t -> f:('-> 'Option.t t) -> 'Option.t t
              val filter : 'Seq.t -> f:('-> bool t) -> 'Seq.t t
              val filter_map :
                'Seq.t -> f:('-> 'Option.t t) -> 'Seq.t t
            end
          val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
          val ( !! ) : '-> 'a t
          val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
          val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
          val ( !$$$ ) :
            ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            'a t -> 'b t -> 'c t -> 'd t -> 'e t
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
          val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
          val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
          module Monad_infix :
            sig
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
            end
          val bind : 'a t -> f:('-> 'b t) -> 'b t
          val return : '-> 'a t
          val map : 'a t -> f:('-> 'b) -> 'b t
          val join : 'a t t -> 'a t
          val ignore_m : 'a t -> unit t
          val all : 'a t list -> 'a list t
          val all_ignore : unit t list -> unit t
          module Let_syntax :
            sig
              val return : '-> 'a t
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              module Let_syntax :
                sig
                  val return : '-> 'a t
                  val bind : 'a t -> f:('-> 'b t) -> 'b t
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val both : 'a t -> 'b t -> ('a * 'b) t
                  module Open_on_rhs : sig  end
                end
            end
          module Syntax :
            sig
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
              val ( !! ) : '-> 'a t
              val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
              val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
            end
        end
      module type S2 =
        sig
          type ('a, 'e) t
          type 'a m
          type ('a, 'e) e
          val lift : 'a m -> ('a, 'e) t
          val run : ('a, 'e) t -> ('a, 'e) e
          val read : unit -> ('e, 'e) t
          val void : ('a, 'e) t -> (unit, 'e) t
          val sequence : (unit, 'e) t List.t -> (unit, 'e) t
          val forever : ('a, 'e) t -> ('b, 'e) t
          module Fn :
            sig
              val id : '-> ('a, 'e) t
              val ignore : ('a, 'e) t -> (unit, 'e) t
              val nothing : unit -> (unit, 'e) t
              val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
              val apply_n_times :
                n:int -> ('-> ('a, 'e) t) -> '-> ('a, 'e) t
              val compose :
                ('-> ('c, 'e) t) -> ('-> ('b, 'e) t) -> '-> ('c, 'e) t
            end
          module Pair :
            sig
              val fst : ('a * 'b, 'e) t -> ('a, 'e) t
              val snd : ('a * 'b, 'e) t -> ('b, 'e) t
            end
          module Triple :
            sig
              val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
              val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
              val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
            end
          module Lift :
            sig
              val nullary : '-> ('a, 'e) t
              val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val binary :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ternary :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val quaternary :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val quinary :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
            end
          module Exn :
            sig
              val expect :
                ?finally:(unit -> (unit, 's) t) ->
                f:(unit -> ('a, 's) t) ->
                catch:(exn -> ('a, 's) t) -> ('a, 's) t
            end
          module Collection :
            sig
              module type S =
                sig
                  type 'a t
                  val all : ('a, 'e) t t -> ('a t, 'e) t
                  val all_ignore : ('a, 'e) t t -> (unit, 'e) t
                  val sequence : (unit, 'e) t t -> (unit, 'e) t
                  val map : 'a t -> f:('-> ('b, 'e) t) -> ('b t, 'e) t
                  val iter : 'a t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                  val fold :
                    'a t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'a t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'a t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'a t -> f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                  val exists : 'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count : 'a t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'a t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                  val find_map :
                    'a t ->
                    f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                  val filter : 'a t -> f:('-> (bool, 'e) t) -> ('a t, 'e) t
                  val filter_map :
                    'a t -> f:('-> ('Option.t, 'e) t) -> ('b t, 'e) t
                end
              module Eager :
                functor (T : Collection.Eager->
                  sig
                    val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                    val all_ignore : ('a, 'e) t T.t -> (unit, 'e) t
                    val sequence : (unit, 'e) t T.t -> (unit, 'e) t
                    val map :
                      'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                    val iter :
                      'T.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                    val fold :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_left :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_right :
                      'T.t ->
                      f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                    val reduce :
                      'T.t ->
                      f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                    val exists :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val for_all :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val count :
                      'T.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                    val find :
                      'T.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                    val find_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                    val filter :
                      'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                    val filter_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                  end
              module Delay :
                functor (T : Collection.Delay->
                  sig
                    val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                    val all_ignore : ('a, 'e) t T.t -> (unit, 'e) t
                    val sequence : (unit, 'e) t T.t -> (unit, 'e) t
                    val map :
                      'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                    val iter :
                      'T.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                    val fold :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_left :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_right :
                      'T.t ->
                      f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                    val reduce :
                      'T.t ->
                      f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                    val exists :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val for_all :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val count :
                      'T.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                    val find :
                      'T.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                    val find_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                    val filter :
                      'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                    val filter_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                  end
            end
          module List :
            sig
              val all : ('a, 'e) t List.t -> ('List.t, 'e) t
              val all_ignore : ('a, 'e) t List.t -> (unit, 'e) t
              val sequence : (unit, 'e) t List.t -> (unit, 'e) t
              val map :
                'List.t -> f:('-> ('b, 'e) t) -> ('List.t, 'e) t
              val iter : 'List.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
              val fold :
                'List.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_left :
                'List.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_right :
                'List.t ->
                f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
              val reduce :
                'List.t ->
                f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
              val exists :
                'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val for_all :
                'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val count : 'List.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'List.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
              val find :
                'List.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
              val find_map :
                'List.t ->
                f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
              val filter :
                'List.t -> f:('-> (bool, 'e) t) -> ('List.t, 'e) t
              val filter_map :
                'List.t ->
                f:('-> ('Option.t, 'e) t) -> ('List.t, 'e) t
            end
          module Seq :
            sig
              val all : ('a, 'e) t Seq.t -> ('Seq.t, 'e) t
              val all_ignore : ('a, 'e) t Seq.t -> (unit, 'e) t
              val sequence : (unit, 'e) t Seq.t -> (unit, 'e) t
              val map : 'Seq.t -> f:('-> ('b, 'e) t) -> ('Seq.t, 'e) t
              val iter : 'Seq.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
              val fold :
                'Seq.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_left :
                'Seq.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_right :
                'Seq.t ->
                f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
              val reduce :
                'Seq.t -> f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
              val exists : 'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val for_all :
                'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val count : 'Seq.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'Seq.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
              val find :
                'Seq.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
              val find_map :
                'Seq.t ->
                f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
              val filter :
                'Seq.t -> f:('-> (bool, 'e) t) -> ('Seq.t, 'e) t
              val filter_map :
                'Seq.t -> f:('-> ('Option.t, 'e) t) -> ('Seq.t, 'e) t
            end
          val ( >=> ) :
            ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
          val ( !! ) : '-> ('a, 'e) t
          val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
          val ( !$$ ) :
            ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
          val ( !$$$ ) :
            ('-> '-> '-> 'd) ->
            ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            ('a, 's) t ->
            ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            ('a, 's) t ->
            ('b, 's) t ->
            ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
          val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
          val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
          module Let_syntax :
            sig
              val return : '-> ('a, 'b) t
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              module Let_syntax :
                sig
                  val return : '-> ('a, 'b) t
                  val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                  val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                  val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                  module Open_on_rhs : sig  end
                end
            end
          module Monad_infix :
            sig
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
            end
          val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
          val return : '-> ('a, 'b) t
          val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
          val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
          val ignore_m : ('a, 'e) t -> (unit, 'e) t
          val all : ('a, 'e) t list -> ('a list, 'e) t
          val all_ignore : (unit, 'e) t list -> (unit, 'e) t
          module Syntax :
            sig
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              val ( >=> ) :
                ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
              val ( !! ) : '-> ('a, 'e) t
              val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val ( !$$ ) :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
            end
        end
      type ('a, 'b) reader
      type ('a, 'e) t = ('a, 'e) reader
      type 'a m = 'a
      type ('a, 'e) e = '-> 'a
      val lift : '-> ('a, 'e) t
      val run : ('a, 'e) t -> ('a, 'e) e
      val read : unit -> ('e, 'e) t
      val void : ('a, 'e) t -> (unit, 'e) t
      val sequence : (unit, 'e) t List.t -> (unit, 'e) t
      val forever : ('a, 'e) t -> ('b, 'e) t
      module Fn :
        sig
          val id : '-> ('a, 'e) t
          val ignore : ('a, 'e) t -> (unit, 'e) t
          val nothing : unit -> (unit, 'e) t
          val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
          val apply_n_times : n:int -> ('-> ('a, 'e) t) -> '-> ('a, 'e) t
          val compose :
            ('-> ('c, 'e) t) -> ('-> ('b, 'e) t) -> '-> ('c, 'e) t
        end
      module Pair :
        sig
          val fst : ('a * 'b, 'e) t -> ('a, 'e) t
          val snd : ('a * 'b, 'e) t -> ('b, 'e) t
        end
      module Triple :
        sig
          val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
          val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
          val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
        end
      module Lift :
        sig
          val nullary : '-> ('a, 'e) t
          val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
          val binary :
            ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
          val ternary :
            ('-> '-> '-> 'd) ->
            ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
          val quaternary :
            ('-> '-> '-> '-> 'e) ->
            ('a, 's) t ->
            ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
          val quinary :
            ('-> '-> '-> '-> '-> 'f) ->
            ('a, 's) t ->
            ('b, 's) t ->
            ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
        end
      module Exn :
        sig
          val expect :
            ?finally:(unit -> (unit, 's) t) ->
            f:(unit -> ('a, 's) t) -> catch:(exn -> ('a, 's) t) -> ('a, 's) t
        end
      module Collection :
        sig
          module type S =
            sig
              type 'a t
              val all : ('a, 'e) reader t -> ('a t, 'e) reader
              val all_ignore : ('a, 'e) reader t -> (unit, 'e) reader
              val sequence : (unit, 'e) reader t -> (unit, 'e) reader
              val map :
                'a t -> f:('-> ('b, 'e) reader) -> ('b t, 'e) reader
              val iter :
                'a t -> f:('-> (unit, 'e) reader) -> (unit, 'e) reader
              val fold :
                'a t ->
                init:'-> f:('-> '-> ('b, 'e) reader) -> ('b, 'e) reader
              val fold_left :
                'a t ->
                init:'-> f:('-> '-> ('b, 'e) reader) -> ('b, 'e) reader
              val fold_right :
                'a t ->
                f:('-> '-> ('b, 'e) reader) -> init:'-> ('b, 'e) reader
              val reduce :
                'a t ->
                f:('-> '-> ('a, 'e) reader) -> ('Option.t, 'e) reader
              val exists :
                'a t -> f:('-> (bool, 'e) reader) -> (bool, 'e) reader
              val for_all :
                'a t -> f:('-> (bool, 'e) reader) -> (bool, 'e) reader
              val count :
                'a t -> f:('-> (bool, 'e) reader) -> (int, 'e) reader
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'b t -> f:('-> ('a, 'e) reader) -> ('a, 'e) reader
              val find :
                'a t ->
                f:('-> (bool, 'e) reader) -> ('Option.t, 'e) reader
              val find_map :
                'a t ->
                f:('-> ('Option.t, 'e) reader) ->
                ('Option.t, 'e) reader
              val filter :
                'a t -> f:('-> (bool, 'e) reader) -> ('a t, 'e) reader
              val filter_map :
                'a t ->
                f:('-> ('Option.t, 'e) reader) -> ('b t, 'e) reader
            end
          module Eager :
            functor (T : Collection.Eager->
              sig
                val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                val all_ignore : ('a, 'e) t T.t -> (unit, 'e) t
                val sequence : (unit, 'e) t T.t -> (unit, 'e) t
                val map : 'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                val iter : 'T.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                val fold :
                  'T.t ->
                  init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                val fold_left :
                  'T.t ->
                  init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                val fold_right :
                  'T.t ->
                  f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                val reduce :
                  'T.t -> f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                val exists : 'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                val for_all :
                  'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                val count : 'T.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                val find :
                  'T.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                val find_map :
                  'T.t ->
                  f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                val filter :
                  'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                val filter_map :
                  'T.t -> f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
              end
          module Delay :
            functor (T : Collection.Delay->
              sig
                val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                val all_ignore : ('a, 'e) t T.t -> (unit, 'e) t
                val sequence : (unit, 'e) t T.t -> (unit, 'e) t
                val map : 'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                val iter : 'T.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                val fold :
                  'T.t ->
                  init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                val fold_left :
                  'T.t ->
                  init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                val fold_right :
                  'T.t ->
                  f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                val reduce :
                  'T.t -> f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                val exists : 'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                val for_all :
                  'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                val count : 'T.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                val find :
                  'T.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                val find_map :
                  'T.t ->
                  f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                val filter :
                  'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                val filter_map :
                  'T.t -> f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
              end
        end
      module List :
        sig
          val all : ('a, 'e) t List.t -> ('List.t, 'e) t
          val all_ignore : ('a, 'e) t List.t -> (unit, 'e) t
          val sequence : (unit, 'e) t List.t -> (unit, 'e) t
          val map : 'List.t -> f:('-> ('b, 'e) t) -> ('List.t, 'e) t
          val iter : 'List.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
          val fold :
            'List.t -> init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
          val fold_left :
            'List.t -> init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
          val fold_right :
            'List.t -> f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
          val reduce :
            'List.t -> f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
          val exists : 'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
          val for_all : 'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
          val count : 'List.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
          val map_reduce :
            (module Monoid.S with type t = 'a) ->
            'List.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
          val find :
            'List.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
          val find_map :
            'List.t -> f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
          val filter :
            'List.t -> f:('-> (bool, 'e) t) -> ('List.t, 'e) t
          val filter_map :
            'List.t -> f:('-> ('Option.t, 'e) t) -> ('List.t, 'e) t
        end
      module Seq :
        sig
          val all : ('a, 'e) t Seq.t -> ('Seq.t, 'e) t
          val all_ignore : ('a, 'e) t Seq.t -> (unit, 'e) t
          val sequence : (unit, 'e) t Seq.t -> (unit, 'e) t
          val map : 'Seq.t -> f:('-> ('b, 'e) t) -> ('Seq.t, 'e) t
          val iter : 'Seq.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
          val fold :
            'Seq.t -> init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
          val fold_left :
            'Seq.t -> init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
          val fold_right :
            'Seq.t -> f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
          val reduce :
            'Seq.t -> f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
          val exists : 'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
          val for_all : 'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
          val count : 'Seq.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
          val map_reduce :
            (module Monoid.S with type t = 'a) ->
            'Seq.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
          val find :
            'Seq.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
          val find_map :
            'Seq.t -> f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
          val filter : 'Seq.t -> f:('-> (bool, 'e) t) -> ('Seq.t, 'e) t
          val filter_map :
            'Seq.t -> f:('-> ('Option.t, 'e) t) -> ('Seq.t, 'e) t
        end
      val ( >=> ) :
        ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
      val ( !! ) : '-> ('a, 'e) t
      val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
      val ( !$$ ) :
        ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
      val ( !$$$ ) :
        ('-> '-> '-> 'd) ->
        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
      val ( !$$$$ ) :
        ('-> '-> '-> '-> 'e) ->
        ('a, 's) t -> ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
      val ( !$$$$$ ) :
        ('-> '-> '-> '-> '-> 'f) ->
        ('a, 's) t ->
        ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
      val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
      module Let_syntax :
        sig
          val return : '-> ('a, 'b) t
          val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
          val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
          module Let_syntax :
            sig
              val return : '-> ('a, 'b) t
              val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
              val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
              val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
              module Open_on_rhs : sig  end
            end
        end
      module Monad_infix :
        sig
          val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
          val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
        end
      val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
      val return : '-> ('a, 'b) t
      val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
      val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
      val ignore_m : ('a, 'e) t -> (unit, 'e) t
      val all : ('a, 'e) t list -> ('a list, 'e) t
      val all_ignore : (unit, 'e) t list -> (unit, 'e) t
      module Syntax :
        sig
          val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
          val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
          val ( >=> ) :
            ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
          val ( !! ) : '-> ('a, 'e) t
          val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
          val ( !$$ ) :
            ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
          val ( !$$$ ) :
            ('-> '-> '-> 'd) ->
            ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            ('a, 's) t ->
            ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            ('a, 's) t ->
            ('b, 's) t ->
            ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
        end
      module T1 :
        functor (T : Core_kernel.Std.T) (M : Monad->
          sig
            type env = T.t
            type 'a m = 'M.t
            type 'a t =
                ('Monads.Std.Monad.Reader.T1.m,
                 Monads.Std.Monad.Reader.T1.env)
                Monads.Std.Monad.Reader.reader
            type 'a e =
                Monads.Std.Monad.Reader.T1.env ->
                'Monads.Std.Monad.Reader.T1.m
          end
      module T2 :
        functor (M : Monad->
          sig
            type 'a m = 'M.t
            type ('a, 'e) t =
                ('Monads.Std.Monad.Reader.T2.m, 'e)
                Monads.Std.Monad.Reader.reader
            type ('a, 'e) e = '-> 'Monads.Std.Monad.Reader.T2.m
          end
      module Make :
        functor (T : Core_kernel.Std.T) (M : Monad->
          sig
            val lift : 'M.t -> 'T1(T)(M).t
            val run : 'T1(T)(M).t -> 'T1(T)(M).e
            val read : unit -> T.t T1(T)(M).t
            val void : 'T1(T)(M).t -> unit T1(T)(M).t
            val sequence : unit T1(T)(M).t list -> unit T1(T)(M).t
            val forever : 'T1(T)(M).t -> 'T1(T)(M).t
            module Fn :
              sig
                val id : '-> 'T1(T)(M).t
                val ignore : 'T1(T)(M).t -> unit T1(T)(M).t
                val nothing : unit -> unit T1(T)(M).t
                val non : ('-> bool T1(T)(M).t) -> '-> bool T1(T)(M).t
                val apply_n_times :
                  n:int -> ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                val compose :
                  ('-> 'T1(T)(M).t) ->
                  ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
              end
            module Pair :
              sig
                val fst : ('a * 'b) T1(T)(M).t -> 'T1(T)(M).t
                val snd : ('a * 'b) T1(T)(M).t -> 'T1(T)(M).t
              end
            module Triple :
              sig
                val fst : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                val snd : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                val trd : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
              end
            module Lift :
              sig
                val nullary : '-> 'T1(T)(M).t
                val unary : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                val binary :
                  ('-> '-> 'c) ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ternary :
                  ('-> '-> '-> 'd) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val quaternary :
                  ('-> '-> '-> '-> 'e) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val quinary :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
              end
            module Exn :
              sig
                val expect :
                  ?finally:(unit -> unit T1(T)(M).t) ->
                  f:(unit -> 'T1(T)(M).t) ->
                  catch:(exn -> 'T1(T)(M).t) -> 'T1(T)(M).t
              end
            module Collection :
              sig
                module type S =
                  sig
                    type 'a t
                    val all : 'T1(T)(M).t t -> 'a t T1(T)(M).t
                    val all_ignore : 'T1(T)(M).t t -> unit T1(T)(M).t
                    val sequence : unit T1(T)(M).t t -> unit T1(T)(M).t
                    val map :
                      'a t -> f:('-> 'T1(T)(M).t) -> 'b t T1(T)(M).t
                    val iter :
                      'a t -> f:('-> unit T1(T)(M).t) -> unit T1(T)(M).t
                    val fold :
                      'a t ->
                      init:'->
                      f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val fold_left :
                      'a t ->
                      init:'->
                      f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val fold_right :
                      'a t ->
                      f:('-> '-> 'T1(T)(M).t) ->
                      init:'-> 'T1(T)(M).t
                    val reduce :
                      'a t ->
                      f:('-> '-> 'T1(T)(M).t) -> 'Option.t T1(T)(M).t
                    val exists :
                      'a t -> f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                    val for_all :
                      'a t -> f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                    val count :
                      'a t -> f:('-> bool T1(T)(M).t) -> int T1(T)(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b t -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val find :
                      'a t ->
                      f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                    val find_map :
                      'a t ->
                      f:('-> 'Option.t T1(T)(M).t) ->
                      'Option.t T1(T)(M).t
                    val filter :
                      'a t -> f:('-> bool T1(T)(M).t) -> 'a t T1(T)(M).t
                    val filter_map :
                      'a t ->
                      f:('-> 'Option.t T1(T)(M).t) -> 'b t T1(T)(M).t
                  end
                module Eager :
                  functor (T : Collection.Eager->
                    sig
                      val all : 'T1(T)(M).t T.t -> 'T.t T1(T)(M).t
                      val all_ignore : 'T1(T)(M).t T.t -> unit T1(T)(M).t
                      val sequence : unit T1(T)(M).t T.t -> unit T1(T)(M).t
                      val map :
                        'T.t ->
                        f:('-> 'T1(T)(M).t) -> 'T.t T1(T)(M).t
                      val iter :
                        'T.t ->
                        f:('-> unit T1(T)(M).t) -> unit T1(T)(M).t
                      val fold :
                        'T.t ->
                        init:'->
                        f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                      val fold_left :
                        'T.t ->
                        init:'->
                        f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> 'T1(T)(M).t) ->
                        init:'-> 'T1(T)(M).t
                      val reduce :
                        'T.t ->
                        f:('-> '-> 'T1(T)(M).t) ->
                        'Option.t T1(T)(M).t
                      val exists :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                      val for_all :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                      val count :
                        'T.t -> f:('-> bool T1(T)(M).t) -> int T1(T)(M).t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                      val find :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                      val find_map :
                        'T.t ->
                        f:('-> 'Option.t T1(T)(M).t) ->
                        'Option.t T1(T)(M).t
                      val filter :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> 'T.t T1(T)(M).t
                      val filter_map :
                        'T.t ->
                        f:('-> 'Option.t T1(T)(M).t) -> 'T.t T1(T)(M).t
                    end
                module Delay :
                  functor (T : Collection.Delay->
                    sig
                      val all : 'T1(T)(M).t T.t -> 'T.t T1(T)(M).t
                      val all_ignore : 'T1(T)(M).t T.t -> unit T1(T)(M).t
                      val sequence : unit T1(T)(M).t T.t -> unit T1(T)(M).t
                      val map :
                        'T.t ->
                        f:('-> 'T1(T)(M).t) -> 'T.t T1(T)(M).t
                      val iter :
                        'T.t ->
                        f:('-> unit T1(T)(M).t) -> unit T1(T)(M).t
                      val fold :
                        'T.t ->
                        init:'->
                        f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                      val fold_left :
                        'T.t ->
                        init:'->
                        f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> 'T1(T)(M).t) ->
                        init:'-> 'T1(T)(M).t
                      val reduce :
                        'T.t ->
                        f:('-> '-> 'T1(T)(M).t) ->
                        'Option.t T1(T)(M).t
                      val exists :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                      val for_all :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                      val count :
                        'T.t -> f:('-> bool T1(T)(M).t) -> int T1(T)(M).t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                      val find :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                      val find_map :
                        'T.t ->
                        f:('-> 'Option.t T1(T)(M).t) ->
                        'Option.t T1(T)(M).t
                      val filter :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> 'T.t T1(T)(M).t
                      val filter_map :
                        'T.t ->
                        f:('-> 'Option.t T1(T)(M).t) -> 'T.t T1(T)(M).t
                    end
              end
            module List :
              sig
                val all : 'T1(T)(M).t list -> 'a list T1(T)(M).t
                val all_ignore : 'T1(T)(M).t list -> unit T1(T)(M).t
                val sequence : unit T1(T)(M).t list -> unit T1(T)(M).t
                val map :
                  'a list -> f:('-> 'T1(T)(M).t) -> 'b list T1(T)(M).t
                val iter :
                  'a list -> f:('-> unit T1(T)(M).t) -> unit T1(T)(M).t
                val fold :
                  'a list ->
                  init:'-> f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val fold_left :
                  'a list ->
                  init:'-> f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val fold_right :
                  'a list ->
                  f:('-> '-> 'T1(T)(M).t) -> init:'-> 'T1(T)(M).t
                val reduce :
                  'a list ->
                  f:('-> '-> 'T1(T)(M).t) -> 'Option.t T1(T)(M).t
                val exists :
                  'a list -> f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                val for_all :
                  'a list -> f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                val count :
                  'a list -> f:('-> bool T1(T)(M).t) -> int T1(T)(M).t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'b list -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val find :
                  'a list ->
                  f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                val find_map :
                  'a list ->
                  f:('-> 'Option.t T1(T)(M).t) -> 'Option.t T1(T)(M).t
                val filter :
                  'a list -> f:('-> bool T1(T)(M).t) -> 'a list T1(T)(M).t
                val filter_map :
                  'a list ->
                  f:('-> 'Option.t T1(T)(M).t) -> 'b list T1(T)(M).t
              end
            module Seq :
              sig
                val all :
                  'T1(T)(M).t Core_kernel.Std.Sequence.t ->
                  'Core_kernel.Std.Sequence.t T1(T)(M).t
                val all_ignore :
                  'T1(T)(M).t Core_kernel.Std.Sequence.t -> unit T1(T)(M).t
                val sequence :
                  unit T1(T)(M).t Core_kernel.Std.Sequence.t ->
                  unit T1(T)(M).t
                val map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> 'T1(T)(M).t) ->
                  'Core_kernel.Std.Sequence.t T1(T)(M).t
                val iter :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> unit T1(T)(M).t) -> unit T1(T)(M).t
                val fold :
                  'Core_kernel.Std.Sequence.t ->
                  init:'-> f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val fold_left :
                  'Core_kernel.Std.Sequence.t ->
                  init:'-> f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val fold_right :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> '-> 'T1(T)(M).t) -> init:'-> 'T1(T)(M).t
                val reduce :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> '-> 'T1(T)(M).t) -> 'Option.t T1(T)(M).t
                val exists :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                val for_all :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                val count :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(T)(M).t) -> int T1(T)(M).t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val find :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                val find_map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> 'Option.t T1(T)(M).t) -> 'Option.t T1(T)(M).t
                val filter :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(T)(M).t) ->
                  'Core_kernel.Std.Sequence.t T1(T)(M).t
                val filter_map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> 'Option.t T1(T)(M).t) ->
                  'Core_kernel.Std.Sequence.t T1(T)(M).t
              end
            val ( >=> ) :
              ('-> 'T1(T)(M).t) ->
              ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
            val ( !! ) : '-> 'T1(T)(M).t
            val ( !$ ) : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
            val ( !$$ ) :
              ('-> '-> 'c) ->
              'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
            val ( !$$$ ) :
              ('-> '-> '-> 'd) ->
              'T1(T)(M).t ->
              'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
            val ( !$$$$ ) :
              ('-> '-> '-> '-> 'e) ->
              'T1(T)(M).t ->
              'T1(T)(M).t ->
              'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
            val ( !$$$$$ ) :
              ('-> '-> '-> '-> '-> 'f) ->
              'T1(T)(M).t ->
              'T1(T)(M).t ->
              'T1(T)(M).t ->
              'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
            val ( >>= ) :
              'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
            val ( >>| ) : 'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
            module Monad_infix :
              sig
                val ( >>= ) :
                  'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val ( >>| ) : 'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
              end
            val bind :
              'T1(T)(M).t -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
            val return : '-> 'T1(T)(M).t
            val map : 'T1(T)(M).t -> f:('-> 'b) -> 'T1(T)(M).t
            val join : 'T1(T)(M).t T1(T)(M).t -> 'T1(T)(M).t
            val ignore_m : 'T1(T)(M).t -> unit T1(T)(M).t
            val all : 'T1(T)(M).t list -> 'a list T1(T)(M).t
            val all_ignore : unit T1(T)(M).t list -> unit T1(T)(M).t
            module Let_syntax :
              sig
                val return : '-> 'T1(T)(M).t
                val ( >>= ) :
                  'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val ( >>| ) : 'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                module Let_syntax :
                  sig
                    val return : '-> 'T1(T)(M).t
                    val bind :
                      'T1(T)(M).t ->
                      f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val map : 'T1(T)(M).t -> f:('-> 'b) -> 'T1(T)(M).t
                    val both :
                      'T1(T)(M).t -> 'T1(T)(M).t -> ('a * 'b) T1(T)(M).t
                    module Open_on_rhs : sig  end
                  end
              end
            module Syntax :
              sig
                val ( >>= ) :
                  'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val ( >>| ) : 'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                val ( >=> ) :
                  ('-> 'T1(T)(M).t) ->
                  ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                val ( !! ) : '-> 'T1(T)(M).t
                val ( !$ ) : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
              end
          end
      module Make2 :
        functor (M : Monad->
          sig
            val lift : 'M.t -> ('a, 'e) T2(M).t
            val run : ('a, 'e) T2(M).t -> ('a, 'e) T2(M).e
            val read : unit -> ('e, 'e) T2(M).t
            val void : ('a, 'e) T2(M).t -> (unit, 'e) T2(M).t
            val sequence : (unit, 'e) T2(M).t list -> (unit, 'e) T2(M).t
            val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
            module Fn :
              sig
                val id : '-> ('a, 'e) T2(M).t
                val ignore : ('a, 'e) T2(M).t -> (unit, 'e) T2(M).t
                val nothing : unit -> (unit, 'e) T2(M).t
                val non :
                  ('-> (bool, 'e) T2(M).t) -> '-> (bool, 'e) T2(M).t
                val apply_n_times :
                  n:int -> ('-> ('a, 'e) T2(M).t) -> '-> ('a, 'e) T2(M).t
                val compose :
                  ('-> ('c, 'e) T2(M).t) ->
                  ('-> ('b, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
              end
            module Pair :
              sig
                val fst : ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
                val snd : ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
              end
            module Triple :
              sig
                val fst : ('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
                val snd : ('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
                val trd : ('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
              end
            module Lift :
              sig
                val nullary : '-> ('a, 'e) T2(M).t
                val unary :
                  ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                val binary :
                  ('-> '-> 'c) ->
                  ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                val ternary :
                  ('-> '-> '-> 'd) ->
                  ('a, 'e) T2(M).t ->
                  ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                val quaternary :
                  ('-> '-> '-> '-> 'e) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t -> ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                val quinary :
                  ('-> '-> '-> '-> '-> 'f) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t ->
                  ('d, 's) T2(M).t -> ('e, 's) T2(M).t -> ('f, 's) T2(M).t
              end
            module Exn :
              sig
                val expect :
                  ?finally:(unit -> (unit, 's) T2(M).t) ->
                  f:(unit -> ('a, 's) T2(M).t) ->
                  catch:(exn -> ('a, 's) T2(M).t) -> ('a, 's) T2(M).t
              end
            module Collection :
              sig
                module type S =
                  sig
                    type 'a t
                    val all : ('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
                    val all_ignore : ('a, 'e) T2(M).t t -> (unit, 'e) T2(M).t
                    val sequence : (unit, 'e) T2(M).t t -> (unit, 'e) T2(M).t
                    val map :
                      'a t ->
                      f:('-> ('b, 'e) T2(M).t) -> ('b t, 'e) T2(M).t
                    val iter :
                      'a t ->
                      f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                    val fold :
                      'a t ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_left :
                      'a t ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_right :
                      'a t ->
                      f:('-> '-> ('b, 'e) T2(M).t) ->
                      init:'-> ('b, 'e) T2(M).t
                    val reduce :
                      'a t ->
                      f:('-> '-> ('a, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val exists :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val for_all :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val count :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b t -> f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                    val find :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val find_map :
                      'a t ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val filter :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) -> ('a t, 'e) T2(M).t
                    val filter_map :
                      'a t ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('b t, 'e) T2(M).t
                  end
                module Eager :
                  functor (T : Collection.Eager->
                    sig
                      val all : ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                      val all_ignore :
                        ('a, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                      val sequence :
                        (unit, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                      val map :
                        'T.t ->
                        f:('-> ('b, 'e) T2(M).t) -> ('T.t, 'e) T2(M).t
                      val iter :
                        'T.t ->
                        f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                      val fold :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                      val fold_left :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> ('b, 'e) T2(M).t) ->
                        init:'-> ('b, 'e) T2(M).t
                      val reduce :
                        'T.t ->
                        f:('-> '-> ('a, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val exists :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                      val for_all :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                      val count :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t ->
                        f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                      val find :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val find_map :
                        'T.t ->
                        f:('-> ('Option.t, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val filter :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> ('T.t, 'e) T2(M).t
                      val filter_map :
                        'T.t ->
                        f:('-> ('Option.t, 'e) T2(M).t) ->
                        ('T.t, 'e) T2(M).t
                    end
                module Delay :
                  functor (T : Collection.Delay->
                    sig
                      val all : ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                      val all_ignore :
                        ('a, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                      val sequence :
                        (unit, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                      val map :
                        'T.t ->
                        f:('-> ('b, 'e) T2(M).t) -> ('T.t, 'e) T2(M).t
                      val iter :
                        'T.t ->
                        f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                      val fold :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                      val fold_left :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> ('b, 'e) T2(M).t) ->
                        init:'-> ('b, 'e) T2(M).t
                      val reduce :
                        'T.t ->
                        f:('-> '-> ('a, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val exists :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                      val for_all :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                      val count :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t ->
                        f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                      val find :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val find_map :
                        'T.t ->
                        f:('-> ('Option.t, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val filter :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> ('T.t, 'e) T2(M).t
                      val filter_map :
                        'T.t ->
                        f:('-> ('Option.t, 'e) T2(M).t) ->
                        ('T.t, 'e) T2(M).t
                    end
              end
            module List :
              sig
                val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                val all_ignore : ('a, 'e) T2(M).t list -> (unit, 'e) T2(M).t
                val sequence : (unit, 'e) T2(M).t list -> (unit, 'e) T2(M).t
                val map :
                  'a list ->
                  f:('-> ('b, 'e) T2(M).t) -> ('b list, 'e) T2(M).t
                val iter :
                  'a list ->
                  f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                val fold :
                  'a list ->
                  init:'->
                  f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val fold_left :
                  'a list ->
                  init:'->
                  f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val fold_right :
                  'a list ->
                  f:('-> '-> ('b, 'e) T2(M).t) ->
                  init:'-> ('b, 'e) T2(M).t
                val reduce :
                  'a list ->
                  f:('-> '-> ('a, 'e) T2(M).t) ->
                  ('Option.t, 'e) T2(M).t
                val exists :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                val for_all :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                val count :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'b list -> f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                val find :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> ('Option.t, 'e) T2(M).t
                val find_map :
                  'a list ->
                  f:('-> ('Option.t, 'e) T2(M).t) ->
                  ('Option.t, 'e) T2(M).t
                val filter :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> ('a list, 'e) T2(M).t
                val filter_map :
                  'a list ->
                  f:('-> ('Option.t, 'e) T2(M).t) ->
                  ('b list, 'e) T2(M).t
              end
            module Seq :
              sig
                val all :
                  ('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                  ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                val all_ignore :
                  ('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                  (unit, 'e) T2(M).t
                val sequence :
                  (unit, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                  (unit, 'e) T2(M).t
                val map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> ('b, 'e) T2(M).t) ->
                  ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                val iter :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                val fold :
                  'Core_kernel.Std.Sequence.t ->
                  init:'->
                  f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val fold_left :
                  'Core_kernel.Std.Sequence.t ->
                  init:'->
                  f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val fold_right :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> '-> ('b, 'e) T2(M).t) ->
                  init:'-> ('b, 'e) T2(M).t
                val reduce :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> '-> ('a, 'e) T2(M).t) ->
                  ('Option.t, 'e) T2(M).t
                val exists :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                val for_all :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                val count :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                val find :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) -> ('Option.t, 'e) T2(M).t
                val find_map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> ('Option.t, 'e) T2(M).t) ->
                  ('Option.t, 'e) T2(M).t
                val filter :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) ->
                  ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                val filter_map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> ('Option.t, 'e) T2(M).t) ->
                  ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
              end
            val ( >=> ) :
              ('-> ('b, 'e) T2(M).t) ->
              ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
            val ( !! ) : '-> ('a, 'e) T2(M).t
            val ( !$ ) : ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
            val ( !$$ ) :
              ('-> '-> 'c) ->
              ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
            val ( !$$$ ) :
              ('-> '-> '-> 'd) ->
              ('a, 'e) T2(M).t ->
              ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
            val ( !$$$$ ) :
              ('-> '-> '-> '-> 'e) ->
              ('a, 's) T2(M).t ->
              ('b, 's) T2(M).t ->
              ('c, 's) T2(M).t -> ('d, 's) T2(M).t -> ('e, 's) T2(M).t
            val ( !$$$$$ ) :
              ('-> '-> '-> '-> '-> 'f) ->
              ('a, 's) T2(M).t ->
              ('b, 's) T2(M).t ->
              ('c, 's) T2(M).t ->
              ('d, 's) T2(M).t -> ('e, 's) T2(M).t -> ('f, 's) T2(M).t
            val ( >>= ) :
              ('a, 'e) T2(M).t ->
              ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
            val ( >>| ) : ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
            module Let_syntax :
              sig
                val return : '-> ('a, 'b) T2(M).t
                val ( >>= ) :
                  ('a, 'e) T2(M).t ->
                  ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val ( >>| ) :
                  ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                module Let_syntax :
                  sig
                    val return : '-> ('a, 'b) T2(M).t
                    val bind :
                      ('a, 'e) T2(M).t ->
                      f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val map :
                      ('a, 'e) T2(M).t -> f:('-> 'b) -> ('b, 'e) T2(M).t
                    val both :
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
                    module Open_on_rhs : sig  end
                  end
              end
            module Monad_infix :
              sig
                val ( >>= ) :
                  ('a, 'e) T2(M).t ->
                  ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val ( >>| ) :
                  ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
              end
            val bind :
              ('a, 'e) T2(M).t ->
              f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
            val return : '-> ('a, 'b) T2(M).t
            val map : ('a, 'e) T2(M).t -> f:('-> 'b) -> ('b, 'e) T2(M).t
            val join : (('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
            val ignore_m : ('a, 'e) T2(M).t -> (unit, 'e) T2(M).t
            val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
            val all_ignore : (unit, 'e) T2(M).t list -> (unit, 'e) T2(M).t
            module Syntax :
              sig
                val ( >>= ) :
                  ('a, 'e) T2(M).t ->
                  ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val ( >>| ) :
                  ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                val ( >=> ) :
                  ('-> ('b, 'e) T2(M).t) ->
                  ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                val ( !! ) : '-> ('a, 'e) T2(M).t
                val ( !$ ) :
                  ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) ->
                  ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  ('a, 'e) T2(M).t ->
                  ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t -> ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t ->
                  ('d, 's) T2(M).t -> ('e, 's) T2(M).t -> ('f, 's) T2(M).t
              end
          end
    end
  module State :
    sig
      type ('a, 'e) storage
      type ('a, 'e) state
      module type S =
        sig
          type 'a t
          type 'a m
          type 'a e
          val lift : 'a m -> 'a t
          val run : 'a t -> 'a e
          val void : 'a t -> unit t
          val sequence : unit t List.t -> unit t
          val forever : 'a t -> 'b t
          module Fn :
            sig
              val id : '-> 'a t
              val ignore : 'a t -> unit t
              val nothing : unit -> unit t
              val non : ('-> bool t) -> '-> bool t
              val apply_n_times : n:int -> ('-> 'a t) -> '-> 'a t
              val compose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
            end
          module Pair :
            sig
              val fst : ('a * 'b) t -> 'a t
              val snd : ('a * 'b) t -> 'b t
            end
          module Triple :
            sig
              val fst : ('a * 'b * 'c) t -> 'a t
              val snd : ('a * 'b * 'c) t -> 'b t
              val trd : ('a * 'b * 'c) t -> 'c t
            end
          module Lift :
            sig
              val nullary : '-> 'a t
              val unary : ('-> 'b) -> 'a t -> 'b t
              val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ternary :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val quaternary :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val quinary :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
            end
          module Exn :
            sig
              val expect :
                ?finally:(unit -> unit t) ->
                f:(unit -> 'a t) -> catch:(exn -> 'a t) -> 'a t
            end
          module Collection :
            sig
              module type S =
                sig
                  type 'a t
                  val all : 'a t t -> 'a t t
                  val all_ignore : 'a t t -> unit t
                  val sequence : unit t t -> unit t
                  val map : 'a t -> f:('-> 'b t) -> 'b t t
                  val iter : 'a t -> f:('-> unit t) -> unit t
                  val fold : 'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce : 'a t -> f:('-> '-> 'a t) -> 'Option.t t
                  val exists : 'a t -> f:('-> bool t) -> bool t
                  val for_all : 'a t -> f:('-> bool t) -> bool t
                  val count : 'a t -> f:('-> bool t) -> int t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b t -> f:('-> 'a t) -> 'a t
                  val find : 'a t -> f:('-> bool t) -> 'Option.t t
                  val find_map :
                    'a t -> f:('-> 'Option.t t) -> 'Option.t t
                  val filter : 'a t -> f:('-> bool t) -> 'a t t
                  val filter_map : 'a t -> f:('-> 'Option.t t) -> 'b t t
                end
              module Eager :
                functor (T : Collection.Eager->
                  sig
                    val all : 'a t T.t -> 'T.t t
                    val all_ignore : 'a t T.t -> unit t
                    val sequence : unit t T.t -> unit t
                    val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                    val iter : 'T.t -> f:('-> unit t) -> unit t
                    val fold :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_left :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_right :
                      'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                    val reduce :
                      'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                    val exists : 'T.t -> f:('-> bool t) -> bool t
                    val for_all : 'T.t -> f:('-> bool t) -> bool t
                    val count : 'T.t -> f:('-> bool t) -> int t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> 'a t) -> 'a t
                    val find : 'T.t -> f:('-> bool t) -> 'Option.t t
                    val find_map :
                      'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                    val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                    val filter_map :
                      'T.t -> f:('-> 'Option.t t) -> 'T.t t
                  end
              module Delay :
                functor (T : Collection.Delay->
                  sig
                    val all : 'a t T.t -> 'T.t t
                    val all_ignore : 'a t T.t -> unit t
                    val sequence : unit t T.t -> unit t
                    val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                    val iter : 'T.t -> f:('-> unit t) -> unit t
                    val fold :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_left :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_right :
                      'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                    val reduce :
                      'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                    val exists : 'T.t -> f:('-> bool t) -> bool t
                    val for_all : 'T.t -> f:('-> bool t) -> bool t
                    val count : 'T.t -> f:('-> bool t) -> int t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> 'a t) -> 'a t
                    val find : 'T.t -> f:('-> bool t) -> 'Option.t t
                    val find_map :
                      'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                    val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                    val filter_map :
                      'T.t -> f:('-> 'Option.t t) -> 'T.t t
                  end
            end
          module List :
            sig
              val all : 'a t List.t -> 'List.t t
              val all_ignore : 'a t List.t -> unit t
              val sequence : unit t List.t -> unit t
              val map : 'List.t -> f:('-> 'b t) -> 'List.t t
              val iter : 'List.t -> f:('-> unit t) -> unit t
              val fold : 'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_left :
                'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_right :
                'List.t -> f:('-> '-> 'b t) -> init:'-> 'b t
              val reduce : 'List.t -> f:('-> '-> 'a t) -> 'Option.t t
              val exists : 'List.t -> f:('-> bool t) -> bool t
              val for_all : 'List.t -> f:('-> bool t) -> bool t
              val count : 'List.t -> f:('-> bool t) -> int t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'List.t -> f:('-> 'a t) -> 'a t
              val find : 'List.t -> f:('-> bool t) -> 'Option.t t
              val find_map :
                'List.t -> f:('-> 'Option.t t) -> 'Option.t t
              val filter : 'List.t -> f:('-> bool t) -> 'List.t t
              val filter_map :
                'List.t -> f:('-> 'Option.t t) -> 'List.t t
            end
          module Seq :
            sig
              val all : 'a t Seq.t -> 'Seq.t t
              val all_ignore : 'a t Seq.t -> unit t
              val sequence : unit t Seq.t -> unit t
              val map : 'Seq.t -> f:('-> 'b t) -> 'Seq.t t
              val iter : 'Seq.t -> f:('-> unit t) -> unit t
              val fold : 'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_left :
                'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_right :
                'Seq.t -> f:('-> '-> 'b t) -> init:'-> 'b t
              val reduce : 'Seq.t -> f:('-> '-> 'a t) -> 'Option.t t
              val exists : 'Seq.t -> f:('-> bool t) -> bool t
              val for_all : 'Seq.t -> f:('-> bool t) -> bool t
              val count : 'Seq.t -> f:('-> bool t) -> int t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'Seq.t -> f:('-> 'a t) -> 'a t
              val find : 'Seq.t -> f:('-> bool t) -> 'Option.t t
              val find_map :
                'Seq.t -> f:('-> 'Option.t t) -> 'Option.t t
              val filter : 'Seq.t -> f:('-> bool t) -> 'Seq.t t
              val filter_map :
                'Seq.t -> f:('-> 'Option.t t) -> 'Seq.t t
            end
          val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
          val ( !! ) : '-> 'a t
          val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
          val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
          val ( !$$$ ) :
            ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            'a t -> 'b t -> 'c t -> 'd t -> 'e t
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
          val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
          val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
          module Monad_infix :
            sig
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
            end
          val bind : 'a t -> f:('-> 'b t) -> 'b t
          val return : '-> 'a t
          val map : 'a t -> f:('-> 'b) -> 'b t
          val join : 'a t t -> 'a t
          val ignore_m : 'a t -> unit t
          val all : 'a t list -> 'a list t
          val all_ignore : unit t list -> unit t
          module Let_syntax :
            sig
              val return : '-> 'a t
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              module Let_syntax :
                sig
                  val return : '-> 'a t
                  val bind : 'a t -> f:('-> 'b t) -> 'b t
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val both : 'a t -> 'b t -> ('a * 'b) t
                  module Open_on_rhs : sig  end
                end
            end
          module Syntax :
            sig
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
              val ( !! ) : '-> 'a t
              val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
              val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
            end
          type env
          val put : Monads.Std.Monad.State.S.env -> unit t
          val get : unit -> Monads.Std.Monad.State.S.env t
          val gets : (Monads.Std.Monad.State.S.env -> 'r) -> 'r t
          val update :
            (Monads.Std.Monad.State.S.env -> Monads.Std.Monad.State.S.env) ->
            unit t
        end
      module type S2 =
        sig
          type ('a, 'e) t
          type 'a m
          type ('a, 'e) e
          val lift : 'a m -> ('a, 'e) t
          val run : ('a, 'e) t -> ('a, 'e) e
          val void : ('a, 'e) t -> (unit, 'e) t
          val sequence : (unit, 'e) t List.t -> (unit, 'e) t
          val forever : ('a, 'e) t -> ('b, 'e) t
          module Fn :
            sig
              val id : '-> ('a, 'e) t
              val ignore : ('a, 'e) t -> (unit, 'e) t
              val nothing : unit -> (unit, 'e) t
              val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
              val apply_n_times :
                n:int -> ('-> ('a, 'e) t) -> '-> ('a, 'e) t
              val compose :
                ('-> ('c, 'e) t) -> ('-> ('b, 'e) t) -> '-> ('c, 'e) t
            end
          module Pair :
            sig
              val fst : ('a * 'b, 'e) t -> ('a, 'e) t
              val snd : ('a * 'b, 'e) t -> ('b, 'e) t
            end
          module Triple :
            sig
              val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
              val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
              val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
            end
          module Lift :
            sig
              val nullary : '-> ('a, 'e) t
              val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val binary :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ternary :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val quaternary :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val quinary :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
            end
          module Exn :
            sig
              val expect :
                ?finally:(unit -> (unit, 's) t) ->
                f:(unit -> ('a, 's) t) ->
                catch:(exn -> ('a, 's) t) -> ('a, 's) t
            end
          module Collection :
            sig
              module type S =
                sig
                  type 'a t
                  val all : ('a, 'e) t t -> ('a t, 'e) t
                  val all_ignore : ('a, 'e) t t -> (unit, 'e) t
                  val sequence : (unit, 'e) t t -> (unit, 'e) t
                  val map : 'a t -> f:('-> ('b, 'e) t) -> ('b t, 'e) t
                  val iter : 'a t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                  val fold :
                    'a t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'a t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'a t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'a t -> f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                  val exists : 'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count : 'a t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'a t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                  val find_map :
                    'a t ->
                    f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                  val filter : 'a t -> f:('-> (bool, 'e) t) -> ('a t, 'e) t
                  val filter_map :
                    'a t -> f:('-> ('Option.t, 'e) t) -> ('b t, 'e) t
                end
              module Eager :
                functor (T : Collection.Eager->
                  sig
                    val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                    val all_ignore : ('a, 'e) t T.t -> (unit, 'e) t
                    val sequence : (unit, 'e) t T.t -> (unit, 'e) t
                    val map :
                      'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                    val iter :
                      'T.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                    val fold :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_left :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_right :
                      'T.t ->
                      f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                    val reduce :
                      'T.t ->
                      f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                    val exists :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val for_all :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val count :
                      'T.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                    val find :
                      'T.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                    val find_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                    val filter :
                      'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                    val filter_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                  end
              module Delay :
                functor (T : Collection.Delay->
                  sig
                    val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                    val all_ignore : ('a, 'e) t T.t -> (unit, 'e) t
                    val sequence : (unit, 'e) t T.t -> (unit, 'e) t
                    val map :
                      'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                    val iter :
                      'T.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                    val fold :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_left :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_right :
                      'T.t ->
                      f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                    val reduce :
                      'T.t ->
                      f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                    val exists :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val for_all :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val count :
                      'T.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                    val find :
                      'T.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                    val find_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                    val filter :
                      'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                    val filter_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                  end
            end
          module List :
            sig
              val all : ('a, 'e) t List.t -> ('List.t, 'e) t
              val all_ignore : ('a, 'e) t List.t -> (unit, 'e) t
              val sequence : (unit, 'e) t List.t -> (unit, 'e) t
              val map :
                'List.t -> f:('-> ('b, 'e) t) -> ('List.t, 'e) t
              val iter : 'List.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
              val fold :
                'List.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_left :
                'List.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_right :
                'List.t ->
                f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
              val reduce :
                'List.t ->
                f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
              val exists :
                'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val for_all :
                'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val count : 'List.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'List.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
              val find :
                'List.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
              val find_map :
                'List.t ->
                f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
              val filter :
                'List.t -> f:('-> (bool, 'e) t) -> ('List.t, 'e) t
              val filter_map :
                'List.t ->
                f:('-> ('Option.t, 'e) t) -> ('List.t, 'e) t
            end
          module Seq :
            sig
              val all : ('a, 'e) t Seq.t -> ('Seq.t, 'e) t
              val all_ignore : ('a, 'e) t Seq.t -> (unit, 'e) t
              val sequence : (unit, 'e) t Seq.t -> (unit, 'e) t
              val map : 'Seq.t -> f:('-> ('b, 'e) t) -> ('Seq.t, 'e) t
              val iter : 'Seq.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
              val fold :
                'Seq.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_left :
                'Seq.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_right :
                'Seq.t ->
                f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
              val reduce :
                'Seq.t -> f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
              val exists : 'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val for_all :
                'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val count : 'Seq.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'Seq.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
              val find :
                'Seq.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
              val find_map :
                'Seq.t ->
                f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
              val filter :
                'Seq.t -> f:('-> (bool, 'e) t) -> ('Seq.t, 'e) t
              val filter_map :
                'Seq.t -> f:('-> ('Option.t, 'e) t) -> ('Seq.t, 'e) t
            end
          val ( >=> ) :
            ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
          val ( !! ) : '-> ('a, 'e) t
          val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
          val ( !$$ ) :
            ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
          val ( !$$$ ) :
            ('-> '-> '-> 'd) ->
            ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            ('a, 's) t ->
            ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            ('a, 's) t ->
            ('b, 's) t ->
            ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
          val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
          val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
          module Let_syntax :
            sig
              val return : '-> ('a, 'b) t
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              module Let_syntax :
                sig
                  val return : '-> ('a, 'b) t
                  val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                  val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                  val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                  module Open_on_rhs : sig  end
                end
            end
          module Monad_infix :
            sig
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
            end
          val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
          val return : '-> ('a, 'b) t
          val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
          val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
          val ignore_m : ('a, 'e) t -> (unit, 'e) t
          val all : ('a, 'e) t list -> ('a list, 'e) t
          val all_ignore : (unit, 'e) t list -> (unit, 'e) t
          module Syntax :
            sig
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              val ( >=> ) :
                ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
              val ( !! ) : '-> ('a, 'e) t
              val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val ( !$$ ) :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
            end
          val put : '-> (unit, 's) t
          val get : unit -> ('s, 's) t
          val gets : ('-> 'r) -> ('r, 's) t
          val update : ('-> 's) -> (unit, 's) t
        end
      module Multi :
        sig
          type status = [ `Current | `Dead | `Live ]
          type 'a contexts
          type id
          module Id :
            sig
              type t = id
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              val of_string : string -> t
              val to_string : t -> string
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
              val ascending : t -> t -> int
              val descending : t -> t -> int
              val between : t -> low:t -> high:t -> bool
              val clamp_exn : t -> min:t -> max:t -> t
              val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
              type comparator_witness
              val validate_lbound :
                min:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_ubound :
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_bound :
                min:t Base__.Maybe_bound.t ->
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              module Replace_polymorphic_compare :
                sig
                  val ( >= ) : t -> t -> bool
                  val ( <= ) : t -> t -> bool
                  val ( = ) : t -> t -> bool
                  val ( > ) : t -> t -> bool
                  val ( < ) : t -> t -> bool
                  val ( <> ) : t -> t -> bool
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val min : t -> t -> t
                  val max : t -> t -> t
                end
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
              module Map :
                sig
                  module Key :
                    sig
                      type t = id
                      val t_of_sexp : Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      val bin_t : t Bin_prot.Type_class.t
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_shape_t : Bin_prot.Shape.t
                      type comparator_witness = comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type 'a t =
                          (id, 'a, comparator_witness)
                          Core_kernel__.Core_map_intf.Tree.t
                      val empty : 'a t
                      val singleton : id -> '-> 'a t
                      val of_alist :
                        (id * 'a) List.t ->
                        [ `Duplicate_key of id | `Ok of 'a t ]
                      val of_alist_or_error :
                        (id * 'a) List.t -> 'a t Base__.Or_error.t
                      val of_alist_exn : (id * 'a) List.t -> 'a t
                      val of_alist_multi : (id * 'a) List.t -> 'List.t t
                      val of_alist_fold :
                        (id * 'a) List.t ->
                        init:'-> f:('-> '-> 'b) -> 'b t
                      val of_alist_reduce :
                        (id * 'a) List.t -> f:('-> '-> 'a) -> 'a t
                      val of_sorted_array :
                        (id * 'a) array -> 'a t Base__.Or_error.t
                      val of_sorted_array_unchecked : (id * 'a) array -> 'a t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> id * 'a) -> 'a t
                      val of_iteri :
                        iteri:(f:(key:id -> data:'-> unit) -> unit) ->
                        [ `Duplicate_key of id | `Ok of 'v t ]
                      val of_tree : 'a t -> 'a t
                      val of_hashtbl_exn :
                        (id, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                      val gen :
                        id Core_kernel__.Quickcheck.Generator.t ->
                        'Core_kernel__.Quickcheck.Generator.t ->
                        'a t Core_kernel__.Quickcheck.Generator.t
                      val invariants : 'a t -> bool
                      val is_empty : 'a t -> bool
                      val length : 'a t -> int
                      val add : 'a t -> key:id -> data:'-> 'a t
                      val add_multi :
                        'List.t t -> key:id -> data:'-> 'List.t t
                      val remove_multi : 'List.t t -> id -> 'List.t t
                      val change :
                        'a t -> id -> f:('Option.t -> 'Option.t) -> 'a t
                      val update :
                        'a t -> id -> f:('Option.t -> 'a) -> 'a t
                      val find : 'a t -> id -> 'Option.t
                      val find_exn : 'a t -> id -> 'a
                      val remove : 'a t -> id -> 'a t
                      val mem : 'a t -> id -> bool
                      val iter_keys : 'a t -> f:(id -> unit) -> unit
                      val iter : 'a t -> f:('-> unit) -> unit
                      val iteri :
                        'a t -> f:(key:id -> data:'-> unit) -> unit
                      val iter2 :
                        'a t ->
                        'b t ->
                        f:(key:id ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           unit) ->
                        unit
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val mapi : 'a t -> f:(key:id -> data:'-> 'b) -> 'b t
                      val fold :
                        'a t ->
                        init:'-> f:(key:id -> data:'-> '-> 'b) -> 'b
                      val fold_right :
                        'a t ->
                        init:'-> f:(key:id -> data:'-> '-> 'b) -> 'b
                      val fold2 :
                        'a t ->
                        'b t ->
                        init:'->
                        f:(key:id ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           '-> 'c) ->
                        'c
                      val filter_keys : 'a t -> f:(id -> bool) -> 'a t
                      val filter : 'a t -> f:('-> bool) -> 'a t
                      val filteri :
                        'a t -> f:(key:id -> data:'-> bool) -> 'a t
                      val filter_map : 'a t -> f:('-> 'Option.t) -> 'b t
                      val filter_mapi :
                        'a t -> f:(key:id -> data:'-> 'Option.t) -> 'b t
                      val partition_mapi :
                        'a t ->
                        f:(key:id -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                        'b t * 'c t
                      val partition_map :
                        'a t ->
                        f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                      val partitioni_tf :
                        'a t -> f:(key:id -> data:'-> bool) -> 'a t * 'a t
                      val partition_tf :
                        'a t -> f:('-> bool) -> 'a t * 'a t
                      val compare_direct :
                        ('-> '-> int) -> 'a t -> 'a t -> int
                      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                      val keys : 'a t -> id List.t
                      val data : 'a t -> 'List.t
                      val to_alist :
                        ?key_order:[ `Decreasing | `Increasing ] ->
                        'a t -> (id * 'a) List.t
                      val validate :
                        name:(id -> string) ->
                        'Base__.Validate.check ->
                        'a t Base__.Validate.check
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:id ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'Option.t) ->
                        'c t
                      val symmetric_diff :
                        'a t ->
                        'a t ->
                        data_equal:('-> '-> bool) ->
                        (id, 'a)
                        Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                        Base__.Sequence.t
                      val min_elt : 'a t -> (id * 'a) Option.t
                      val min_elt_exn : 'a t -> id * 'a
                      val max_elt : 'a t -> (id * 'a) Option.t
                      val max_elt_exn : 'a t -> id * 'a
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val for_alli :
                        'a t -> f:(key:id -> data:'-> bool) -> bool
                      val exists : 'a t -> f:('-> bool) -> bool
                      val existsi :
                        'a t -> f:(key:id -> data:'-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val counti :
                        'a t -> f:(key:id -> data:'-> bool) -> int
                      val split :
                        'a t -> id -> 'a t * (id * 'a) Option.t * 'a t
                      val append :
                        lower_part:'a t ->
                        upper_part:'a t ->
                        [ `Ok of 'a t | `Overlapping_key_ranges ]
                      val subrange :
                        'a t ->
                        lower_bound:id Base__.Maybe_bound.t ->
                        upper_bound:id Base__.Maybe_bound.t -> 'a t
                      val fold_range_inclusive :
                        'a t ->
                        min:id ->
                        max:id ->
                        init:'-> f:(key:id -> data:'-> '-> 'b) -> 'b
                      val range_to_alist :
                        'a t -> min:id -> max:id -> (id * 'a) List.t
                      val closest_key :
                        'a t ->
                        [ `Greater_or_equal_to
                        | `Greater_than
                        | `Less_or_equal_to
                        | `Less_than ] -> id -> (id * 'a) Option.t
                      val nth : 'a t -> int -> (id * 'a) Option.t
                      val nth_exn : 'a t -> int -> id * 'a
                      val rank : 'a t -> id -> int Option.t
                      val to_tree : 'a t -> 'a t
                      val to_sequence :
                        ?order:[ `Decreasing_key | `Increasing_key ] ->
                        ?keys_greater_or_equal_to:id ->
                        ?keys_less_or_equal_to:id ->
                        'a t -> (id * 'a) Base__.Sequence.t
                      val obs :
                        id Core_kernel__.Quickcheck.Observer.t ->
                        'Core_kernel__.Quickcheck.Observer.t ->
                        'v t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        id Core_kernel__.Quickcheck.Shrinker.t ->
                        'Core_kernel__.Quickcheck.Shrinker.t ->
                        'v t Core_kernel__.Quickcheck.Shrinker.t
                      module Provide_of_sexp :
                        functor
                          (K : sig val t_of_sexp : Sexplib.Sexp.t -> id end->
                          sig
                            val t_of_sexp :
                              (Sexplib.Sexp.t -> 'v_x__017_) ->
                              Sexplib.Sexp.t -> 'v_x__017_ t
                          end
                      val t_of_sexp :
                        (Base__.Sexplib.Sexp.t -> 'a) ->
                        Base__.Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Base__.Sexplib.Sexp.t) ->
                        'a t -> Base__.Sexplib.Sexp.t
                    end
                  type 'a t =
                      (id, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Map.t
                  val compare :
                    ('-> '-> Core_kernel__.Import.int) ->
                    'a t -> 'a t -> Core_kernel__.Import.int
                  val empty : 'a t
                  val singleton : id -> '-> 'a t
                  val of_alist :
                    (id * 'a) List.t ->
                    [ `Duplicate_key of id | `Ok of 'a t ]
                  val of_alist_or_error :
                    (id * 'a) List.t -> 'a t Base__.Or_error.t
                  val of_alist_exn : (id * 'a) List.t -> 'a t
                  val of_alist_multi : (id * 'a) List.t -> 'List.t t
                  val of_alist_fold :
                    (id * 'a) List.t -> init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (id * 'a) List.t -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (id * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (id * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> id * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:id -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of id | `Ok of 'v t ]
                  val of_tree : 'Tree.t -> 'a t
                  val of_hashtbl_exn :
                    (id, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    id Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:id -> data:'-> 'a t
                  val add_multi :
                    'List.t t -> key:id -> data:'-> 'List.t t
                  val remove_multi : 'List.t t -> id -> 'List.t t
                  val change :
                    'a t -> id -> f:('Option.t -> 'Option.t) -> 'a t
                  val update : 'a t -> id -> f:('Option.t -> 'a) -> 'a t
                  val find : 'a t -> id -> 'Option.t
                  val find_exn : 'a t -> id -> 'a
                  val remove : 'a t -> id -> 'a t
                  val mem : 'a t -> id -> bool
                  val iter_keys : 'a t -> f:(id -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri : 'a t -> f:(key:id -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:id ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:id -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:id -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:id -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:id ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(id -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri : 'a t -> f:(key:id -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'Option.t) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:id -> data:'-> 'Option.t) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:id -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:id -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> id List.t
                  val data : 'a t -> 'List.t
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (id * 'a) List.t
                  val validate :
                    name:(id -> string) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:id ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'Option.t) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (id, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (id * 'a) Option.t
                  val min_elt_exn : 'a t -> id * 'a
                  val max_elt : 'a t -> (id * 'a) Option.t
                  val max_elt_exn : 'a t -> id * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:id -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi : 'a t -> f:(key:id -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti : 'a t -> f:(key:id -> data:'-> bool) -> int
                  val split : 'a t -> id -> 'a t * (id * 'a) Option.t * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:id Base__.Maybe_bound.t ->
                    upper_bound:id Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:id ->
                    max:id ->
                    init:'-> f:(key:id -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:id -> max:id -> (id * 'a) List.t
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> id -> (id * 'a) Option.t
                  val nth : 'a t -> int -> (id * 'a) Option.t
                  val nth_exn : 'a t -> int -> id * 'a
                  val rank : 'a t -> id -> int Option.t
                  val to_tree : 'a t -> 'Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:id ->
                    ?keys_less_or_equal_to:id ->
                    'a t -> (id * 'a) Base__.Sequence.t
                  val obs :
                    id Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    id Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (Key : sig val t_of_sexp : Sexplib.Sexp.t -> id end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__018_) ->
                          Sexplib.Sexp.t -> 'v_x__018_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : id Bin_prot.Type_class.t
                               val bin_read_t : id Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> id)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 id Bin_prot.Type_class.reader
                               val bin_size_t : id Bin_prot.Size.sizer
                               val bin_write_t : id Bin_prot.Write.writer
                               val bin_writer_t :
                                 id Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                        val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                        val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                        val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                        val __bin_read_t__ :
                          ('a, int -> 'a t) Bin_prot.Read.reader1
                        val bin_writer_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.writer
                        val bin_reader_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.reader
                        val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                      end
                  module Provide_hash :
                    functor
                      (Key : sig
                               val hash_fold_t :
                                 Base__.Hash.state -> id -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          (Ppx_hash_lib.Std.Hash.state ->
                           '-> Ppx_hash_lib.Std.Hash.state) ->
                          Ppx_hash_lib.Std.Hash.state ->
                          'a t -> Ppx_hash_lib.Std.Hash.state
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                  val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                  val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                  val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                  val __bin_read_t__ :
                    ('a, int -> 'a t) Bin_prot.Read.reader1
                  val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                  val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                  val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                end
              module Set :
                sig
                  module Elt :
                    sig
                      type t = id
                      val bin_t : t Bin_prot.Type_class.t
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_shape_t : Bin_prot.Shape.t
                      val t_of_sexp : Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      type comparator_witness = Map.Key.comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type t =
                          (id, comparator_witness)
                          Core_kernel__.Core_set_intf.Tree.t
                      val compare : t -> t -> Core_kernel__.Import.int
                      val length : t -> int
                      val is_empty : t -> bool
                      val iter : t -> f:(id -> unit) -> unit
                      val fold :
                        t ->
                        init:'accum -> f:('accum -> id -> 'accum) -> 'accum
                      val fold_result :
                        t ->
                        init:'accum ->
                        f:('accum -> id -> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val exists : t -> f:(id -> bool) -> bool
                      val for_all : t -> f:(id -> bool) -> bool
                      val count : t -> f:(id -> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        t -> f:(id -> 'sum) -> 'sum
                      val find : t -> f:(id -> bool) -> id Option.t
                      val find_map :
                        t -> f:(id -> 'Option.t) -> 'Option.t
                      val to_list : t -> id List.t
                      val to_array : t -> id array
                      val invariants : t -> bool
                      val mem : t -> id -> bool
                      val add : t -> id -> t
                      val remove : t -> id -> t
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val symmetric_diff :
                        t -> t -> (id, id) Base__.Either.t Base__.Sequence.t
                      val compare_direct : t -> t -> int
                      val equal : t -> t -> bool
                      val is_subset : t -> of_:t -> bool
                      val subset : t -> t -> bool
                      val fold_until :
                        t ->
                        init:'->
                        f:('->
                           id ->
                           ('b, 'stop)
                           Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                        ('b, 'stop)
                        Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                      val fold_right :
                        t -> init:'-> f:(id -> '-> 'b) -> 'b
                      val iter2 :
                        t ->
                        t ->
                        f:([ `Both of id * id | `Left of id | `Right of id ] ->
                           unit) ->
                        unit
                      val filter : t -> f:(id -> bool) -> t
                      val partition_tf : t -> f:(id -> bool) -> t * t
                      val elements : t -> id List.t
                      val min_elt : t -> id Option.t
                      val min_elt_exn : t -> id
                      val max_elt : t -> id Option.t
                      val max_elt_exn : t -> id
                      val choose : t -> id Option.t
                      val choose_exn : t -> id
                      val split : t -> id -> t * id Option.t * t
                      val group_by :
                        t -> equiv:(id -> id -> bool) -> t List.t
                      val find_exn : t -> f:(id -> bool) -> id
                      val find_index : t -> int -> id Option.t
                      val nth : t -> int -> id Option.t
                      val remove_index : t -> int -> t
                      val to_tree : t -> t
                      val to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:id ->
                        ?less_or_equal_to:id -> t -> id Base__.Sequence.t
                      val merge_to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:id ->
                        ?less_or_equal_to:id ->
                        t ->
                        t ->
                        (id, id)
                        Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                        Base__.Sequence.t
                      val to_map :
                        t ->
                        f:(id -> 'data) ->
                        (id, 'data, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t
                      val obs :
                        id Core_kernel__.Quickcheck.Observer.t ->
                        t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        id Core_kernel__.Quickcheck.Shrinker.t ->
                        t Core_kernel__.Quickcheck.Shrinker.t
                      val empty : t
                      val singleton : id -> t
                      val union_list : t List.t -> t
                      val of_list : id List.t -> t
                      val of_array : id array -> t
                      val of_sorted_array : id array -> t Base__.Or_error.t
                      val of_sorted_array_unchecked : id array -> t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> id) -> t
                      val stable_dedup_list : id List.t -> id List.t
                      val map :
                        ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                        f:('-> id) -> t
                      val filter_map :
                        ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                        f:('-> id Option.t) -> t
                      val of_tree : t -> t
                      val of_hash_set : id Core_kernel__.Hash_set.t -> t
                      val of_hashtbl_keys :
                        (id, 'a) Core_kernel__.Core_hashtbl.t -> t
                      val of_map_keys :
                        (id, 'a, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t -> t
                      val gen :
                        id Core_kernel__.Quickcheck.Generator.t ->
                        t Core_kernel__.Quickcheck.Generator.t
                      module Provide_of_sexp :
                        functor
                          (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> id end->
                          sig val t_of_sexp : Sexplib.Sexp.t -> t end
                      val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                    end
                  type t = (id, comparator_witness) Base.Set.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(id -> unit) -> unit
                  val fold :
                    t -> init:'accum -> f:('accum -> id -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> id -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(id -> bool) -> bool
                  val for_all : t -> f:(id -> bool) -> bool
                  val count : t -> f:(id -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(id -> 'sum) -> 'sum
                  val find : t -> f:(id -> bool) -> id Option.t
                  val find_map : t -> f:(id -> 'Option.t) -> 'Option.t
                  val to_list : t -> id List.t
                  val to_array : t -> id array
                  val invariants : t -> bool
                  val mem : t -> id -> bool
                  val add : t -> id -> t
                  val remove : t -> id -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t -> t -> (id, id) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       id ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right : t -> init:'-> f:(id -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of id * id | `Left of id | `Right of id ] ->
                       unit) ->
                    unit
                  val filter : t -> f:(id -> bool) -> t
                  val partition_tf : t -> f:(id -> bool) -> t * t
                  val elements : t -> id List.t
                  val min_elt : t -> id Option.t
                  val min_elt_exn : t -> id
                  val max_elt : t -> id Option.t
                  val max_elt_exn : t -> id
                  val choose : t -> id Option.t
                  val choose_exn : t -> id
                  val split : t -> id -> t * id Option.t * t
                  val group_by : t -> equiv:(id -> id -> bool) -> t List.t
                  val find_exn : t -> f:(id -> bool) -> id
                  val find_index : t -> int -> id Option.t
                  val nth : t -> int -> id Option.t
                  val remove_index : t -> int -> t
                  val to_tree : t -> Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:id ->
                    ?less_or_equal_to:id -> t -> id Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:id ->
                    ?less_or_equal_to:id ->
                    t ->
                    t ->
                    (id, id)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(id -> 'data) ->
                    (id, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    id Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    id Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : id -> t
                  val union_list : t List.t -> t
                  val of_list : id List.t -> t
                  val of_array : id array -> t
                  val of_sorted_array : id array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : id array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> id) -> t
                  val stable_dedup_list : id List.t -> id List.t
                  val map : ('a, 'b) Base.Set.t -> f:('-> id) -> t
                  val filter_map :
                    ('a, 'b) Base.Set.t -> f:('-> id Option.t) -> t
                  val of_tree : Tree.t -> t
                  val of_hash_set : id Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (id, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (id, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    id Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> id end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (Elt : sig
                               val bin_t : id Bin_prot.Type_class.t
                               val bin_read_t : id Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> id)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 id Bin_prot.Type_class.reader
                               val bin_size_t : id Bin_prot.Size.sizer
                               val bin_write_t : id Bin_prot.Write.writer
                               val bin_writer_t :
                                 id Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                        val bin_shape_t : Bin_prot.Shape.t
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_t : t Bin_prot.Type_class.t
                      end
                  module Provide_hash :
                    functor
                      (Elt : sig
                               val hash_fold_t :
                                 Base__.Hash.state -> id -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          Ppx_hash_lib.Std.Hash.state ->
                          t -> Ppx_hash_lib.Std.Hash.state
                        val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                      end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                  val bin_shape_t : Bin_prot.Shape.t
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_t : t Bin_prot.Type_class.t
                end
              val hash : t -> Core_kernel__.Import.int
              val hashable : t Core_kernel__.Hashable.Hashtbl.Hashable.t
              module Table :
                sig
                  type key = t
                  type ('a, 'b) hashtbl =
                      ('a, 'b) Core_kernel__.Hashable.Hashtbl.t
                  type 'b t = (key, 'b) hashtbl
                  val sexp_of_t :
                    ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                  type ('a, 'b) t_ = 'b t
                  type 'a key_ = key
                  val hashable :
                    key Core_kernel__.Core_hashtbl_intf.Hashable.t
                  val invariant :
                    'Base__.Invariant_intf.inv ->
                    'a t Base__.Invariant_intf.inv
                  val create :
                    (key, 'b, unit -> 'b t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist :
                    (key, 'b,
                     (key * 'b) List.t ->
                     [ `Duplicate_key of key | `Ok of 'b t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_report_all_dups :
                    (key, 'b,
                     (key * 'b) List.t ->
                     [ `Duplicate_keys of key List.t | `Ok of 'b t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_or_error :
                    (key, 'b, (key * 'b) List.t -> 'b t Base__.Or_error.t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_exn :
                    (key, 'b, (key * 'b) List.t -> 'b t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_multi :
                    (key, 'List.t, (key * 'b) List.t -> 'List.t t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_mapped :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     'List.t ->
                     [ `Duplicate_keys of key List.t | `Ok of 'b t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_with_key :
                    (key, 'r,
                     get_key:('-> key) ->
                     'List.t ->
                     [ `Duplicate_keys of key List.t | `Ok of 'r t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_with_key_or_error :
                    (key, 'r,
                     get_key:('-> key) ->
                     'List.t -> 'r t Base__.Or_error.t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_with_key_exn :
                    (key, 'r, get_key:('-> key) -> 'List.t -> 'r t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val group :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     combine:('-> '-> 'b) -> 'List.t -> 'b t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                  val clear : 'a t -> unit
                  val copy : 'b t -> 'b t
                  val fold :
                    'b t ->
                    init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                  val iter_keys : 'a t -> f:(key -> unit) -> unit
                  val iter : 'b t -> f:('-> unit) -> unit
                  val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
                  val iter_vals : 'b t -> f:('-> unit) -> unit
                  val existsi :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val exists : 'b t -> f:('-> bool) -> bool
                  val for_alli :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val for_all : 'b t -> f:('-> bool) -> bool
                  val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
                  val count : 'b t -> f:('-> bool) -> int
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val mem : 'a t -> key -> bool
                  val remove : 'a t -> key -> unit
                  val replace : 'b t -> key:key -> data:'-> unit
                  val set : 'b t -> key:key -> data:'-> unit
                  val add :
                    'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                  val add_or_error :
                    'b t -> key:key -> data:'-> unit Base__.Or_error.t
                  val add_exn : 'b t -> key:key -> data:'-> unit
                  val change :
                    'b t -> key -> f:('Option.t -> 'Option.t) -> unit
                  val update : 'b t -> key -> f:('Option.t -> 'b) -> unit
                  val add_multi : 'List.t t -> key:key -> data:'-> unit
                  val remove_multi : 'List.t t -> key -> unit
                  val map : 'b t -> f:('-> 'c) -> 'c t
                  val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                  val filter_map : 'b t -> f:('-> 'Option.t) -> 'c t
                  val filter_mapi :
                    'b t -> f:(key:key -> data:'-> 'Option.t) -> 'c t
                  val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                  val filter : 'b t -> f:('-> bool) -> 'b t
                  val filteri :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t
                  val partition_map :
                    'b t ->
                    f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
                  val partition_mapi :
                    'b t ->
                    f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                    'c t * 'd t
                  val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
                  val partitioni_tf :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
                  val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
                  val find : 'b t -> key -> 'Option.t
                  val find_exn : 'b t -> key -> 'b
                  val find_and_call :
                    'b t ->
                    key ->
                    if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
                  val find_and_remove : 'b t -> key -> 'Option.t
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:key ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'Option.t) ->
                    'c t
                  type 'a merge_into_action = Remove | Set_to of 'a
                  val merge_into :
                    src:'a t ->
                    dst:'b t ->
                    f:(key:key -> '-> 'Option.t -> 'b merge_into_action) ->
                    unit
                  val keys : 'a t -> key List.t
                  val data : 'b t -> 'List.t
                  val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
                  val filter_inplace : 'b t -> f:('-> bool) -> unit
                  val filteri_inplace :
                    'b t -> f:(key:key -> data:'-> bool) -> unit
                  val map_inplace : 'b t -> f:('-> 'b) -> unit
                  val mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b) -> unit
                  val filter_map_inplace :
                    'b t -> f:('-> 'Option.t) -> unit
                  val filter_mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'Option.t) -> unit
                  val replace_all : 'b t -> f:('-> 'b) -> unit
                  val replace_alli :
                    'b t -> f:(key:key -> data:'-> 'b) -> unit
                  val filter_replace_all :
                    'b t -> f:('-> 'Option.t) -> unit
                  val filter_replace_alli :
                    'b t -> f:(key:key -> data:'-> 'Option.t) -> unit
                  val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
                  val similar :
                    'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                  val to_alist : 'b t -> (key * 'b) List.t
                  val validate :
                    name:(key -> string) ->
                    'Base__.Validate.check -> 'b t Base__.Validate.check
                  val incr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  val decr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  module Provide_of_sexp :
                    functor
                      (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__001_) ->
                          Sexplib.Sexp.t -> 'v_x__001_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : key Bin_prot.Type_class.t
                               val bin_read_t : key Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> key)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 key Bin_prot.Type_class.reader
                               val bin_size_t : key Bin_prot.Size.sizer
                               val bin_write_t : key Bin_prot.Write.writer
                               val bin_writer_t :
                                 key Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_t :
                          'Bin_prot.Type_class.t ->
                          'a t Bin_prot.Type_class.t
                        val bin_read_t :
                          'Bin_prot.Read.reader ->
                          'a t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          'Bin_prot.Read.reader ->
                          (Core_kernel__.Import.int -> 'a t)
                          Bin_prot.Read.reader
                        val bin_reader_t :
                          'Bin_prot.Type_class.reader ->
                          'a t Bin_prot.Type_class.reader
                        val bin_size_t :
                          'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                        val bin_write_t :
                          'Bin_prot.Write.writer ->
                          'a t Bin_prot.Write.writer
                        val bin_writer_t :
                          'Bin_prot.Type_class.writer ->
                          'a t Bin_prot.Type_class.writer
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                      end
                  val t_of_sexp :
                    (Sexplib.Sexp.t -> 'v_x__002_) ->
                    Sexplib.Sexp.t -> 'v_x__002_ t
                  val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                  val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                  val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                  val __bin_read_t__ :
                    ('a, int -> 'a t) Bin_prot.Read.reader1
                  val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                  val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                  val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                end
              module Hash_set :
                sig
                  type elt = t
                  type t = elt Core_kernel__.Hash_set.t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type 'a t_ = t
                  type 'a elt_ = elt
                  val create :
                    ('a, unit -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_hashable
                  val of_list :
                    ('a, elt List.t -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_hashable
                  module Provide_of_sexp :
                    functor
                      (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (X : sig
                             val bin_t : elt Bin_prot.Type_class.t
                             val bin_read_t : elt Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> elt)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               elt Bin_prot.Type_class.reader
                             val bin_size_t : elt Bin_prot.Size.sizer
                             val bin_write_t : elt Bin_prot.Write.writer
                             val bin_writer_t :
                               elt Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end->
                      sig
                        val bin_t : t Bin_prot.Type_class.t
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          (Core_kernel__.Import.int -> t)
                          Bin_prot.Read.reader
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_shape_t : Bin_prot.Shape.t
                      end
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                  val bin_shape_t : Bin_prot.Shape.t
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_t : t Bin_prot.Type_class.t
                end
              module Hash_queue :
                sig
                  module Key :
                    sig
                      type t = id
                      val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                      val compare : t -> t -> int
                      val hash : t -> int
                    end
                  type 'a t
                  val sexp_of_t :
                    ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val iter : 'a t -> f:('-> unit) -> unit
                  val fold :
                    'a t ->
                    init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                  val fold_result :
                    'a t ->
                    init:'accum ->
                    f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val fold_until :
                    'a t ->
                    init:'accum ->
                    f:('accum ->
                       '->
                       ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                    ('accum, 'stop)
                    Base.Container_intf.Finished_or_stopped_early.t
                  val exists : 'a t -> f:('-> bool) -> bool
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    'a t -> f:('-> 'sum) -> 'sum
                  val find : 'a t -> f:('-> bool) -> 'Option.t
                  val find_map : 'a t -> f:('-> 'Option.t) -> 'Option.t
                  val to_list : 'a t -> 'List.t
                  val to_array : 'a t -> 'a array
                  val min_elt : 'a t -> cmp:('-> '-> int) -> 'Option.t
                  val max_elt : 'a t -> cmp:('-> '-> int) -> 'Option.t
                  val invariant : 'a t -> Core_kernel__.Import.unit
                  val create :
                    ?growth_allowed:Core_kernel__.Import.bool ->
                    ?size:Core_kernel__.Import.int ->
                    Core_kernel__.Import.unit -> 'a t
                  val clear : 'a t -> Core_kernel__.Import.unit
                  val mem : 'a t -> id -> Core_kernel__.Import.bool
                  val lookup : 'a t -> id -> 'Core_kernel__.Import.option
                  val lookup_exn : 'a t -> id -> 'a
                  val enqueue :
                    'a t -> id -> '-> [ `Key_already_present | `Ok ]
                  val enqueue_exn :
                    'a t -> id -> '-> Core_kernel__.Import.unit
                  val lookup_and_move_to_back :
                    'a t -> id -> 'Core_kernel__.Import.option
                  val lookup_and_move_to_back_exn : 'a t -> id -> 'a
                  val first : 'a t -> 'Core_kernel__.Import.option
                  val first_with_key :
                    'a t -> (id * 'a) Core_kernel__.Import.option
                  val keys : 'a t -> id Core_kernel__.Import.list
                  val dequeue : 'a t -> 'Core_kernel__.Import.option
                  val dequeue_exn : 'a t -> 'a
                  val dequeue_with_key :
                    'a t -> (id * 'a) Core_kernel__.Import.option
                  val dequeue_with_key_exn : 'a t -> id * 'a
                  val dequeue_all :
                    'a t ->
                    f:('-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val remove : 'a t -> id -> [ `No_such_key | `Ok ]
                  val remove_exn : 'a t -> id -> Core_kernel__.Import.unit
                  val replace : 'a t -> id -> '-> [ `No_such_key | `Ok ]
                  val replace_exn :
                    'a t -> id -> '-> Core_kernel__.Import.unit
                  val iteri :
                    'a t ->
                    f:(key:id -> data:'-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val foldi :
                    'a t ->
                    init:'-> f:('-> key:id -> data:'-> 'b) -> 'b
                end
              val pp :
                Format.formatter -> Monads.Std.Monad.State.Multi.id -> unit
            end
          module type S =
            sig
              type 'a t
              type 'a m
              type 'a e
              type id
              module Id :
                sig
                  type t = id
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  val of_string : string -> t
                  val to_string : t -> string
                  val ( >= ) : t -> t -> bool
                  val ( <= ) : t -> t -> bool
                  val ( = ) : t -> t -> bool
                  val ( > ) : t -> t -> bool
                  val ( < ) : t -> t -> bool
                  val ( <> ) : t -> t -> bool
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val min : t -> t -> t
                  val max : t -> t -> t
                  val ascending : t -> t -> int
                  val descending : t -> t -> int
                  val between : t -> low:t -> high:t -> bool
                  val clamp_exn : t -> min:t -> max:t -> t
                  val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
                  type comparator_witness
                  val validate_lbound :
                    min:t Base__.Maybe_bound.t -> t Base__.Validate.check
                  val validate_ubound :
                    max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                  val validate_bound :
                    min:t Base__.Maybe_bound.t ->
                    max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                  module Replace_polymorphic_compare :
                    sig
                      val ( >= ) : t -> t -> bool
                      val ( <= ) : t -> t -> bool
                      val ( = ) : t -> t -> bool
                      val ( > ) : t -> t -> bool
                      val ( < ) : t -> t -> bool
                      val ( <> ) : t -> t -> bool
                      val equal : t -> t -> bool
                      val compare : t -> t -> int
                      val min : t -> t -> t
                      val max : t -> t -> t
                    end
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                  module Map :
                    sig
                      module Key :
                        sig
                          type t = id
                          val t_of_sexp : Sexplib.Sexp.t -> t
                          val sexp_of_t : t -> Sexplib.Sexp.t
                          val bin_t : t Bin_prot.Type_class.t
                          val bin_read_t : t Bin_prot.Read.reader
                          val __bin_read_t__ :
                            (Core_kernel__.Import.int -> t)
                            Bin_prot.Read.reader
                          val bin_reader_t : t Bin_prot.Type_class.reader
                          val bin_size_t : t Bin_prot.Size.sizer
                          val bin_write_t : t Bin_prot.Write.writer
                          val bin_writer_t : t Bin_prot.Type_class.writer
                          val bin_shape_t : Bin_prot.Shape.t
                          type comparator_witness = comparator_witness
                          val comparator :
                            (t, comparator_witness)
                            Core_kernel__.Comparator.comparator
                        end
                      module Tree :
                        sig
                          type 'a t =
                              (id, 'a, comparator_witness)
                              Core_kernel__.Core_map_intf.Tree.t
                          val empty : 'a t
                          val singleton : id -> '-> 'a t
                          val of_alist :
                            (id * 'a) List.t ->
                            [ `Duplicate_key of id | `Ok of 'a t ]
                          val of_alist_or_error :
                            (id * 'a) List.t -> 'a t Base__.Or_error.t
                          val of_alist_exn : (id * 'a) List.t -> 'a t
                          val of_alist_multi :
                            (id * 'a) List.t -> 'List.t t
                          val of_alist_fold :
                            (id * 'a) List.t ->
                            init:'-> f:('-> '-> 'b) -> 'b t
                          val of_alist_reduce :
                            (id * 'a) List.t -> f:('-> '-> 'a) -> 'a t
                          val of_sorted_array :
                            (id * 'a) array -> 'a t Base__.Or_error.t
                          val of_sorted_array_unchecked :
                            (id * 'a) array -> 'a t
                          val of_increasing_iterator_unchecked :
                            len:int -> f:(int -> id * 'a) -> 'a t
                          val of_iteri :
                            iteri:(f:(key:id -> data:'-> unit) -> unit) ->
                            [ `Duplicate_key of id | `Ok of 'v t ]
                          val of_tree : 'a t -> 'a t
                          val of_hashtbl_exn :
                            (id, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                          val gen :
                            id Core_kernel__.Quickcheck.Generator.t ->
                            'Core_kernel__.Quickcheck.Generator.t ->
                            'a t Core_kernel__.Quickcheck.Generator.t
                          val invariants : 'a t -> bool
                          val is_empty : 'a t -> bool
                          val length : 'a t -> int
                          val add : 'a t -> key:id -> data:'-> 'a t
                          val add_multi :
                            'List.t t -> key:id -> data:'-> 'List.t t
                          val remove_multi : 'List.t t -> id -> 'List.t t
                          val change :
                            'a t ->
                            id -> f:('Option.t -> 'Option.t) -> 'a t
                          val update :
                            'a t -> id -> f:('Option.t -> 'a) -> 'a t
                          val find : 'a t -> id -> 'Option.t
                          val find_exn : 'a t -> id -> 'a
                          val remove : 'a t -> id -> 'a t
                          val mem : 'a t -> id -> bool
                          val iter_keys : 'a t -> f:(id -> unit) -> unit
                          val iter : 'a t -> f:('-> unit) -> unit
                          val iteri :
                            'a t -> f:(key:id -> data:'-> unit) -> unit
                          val iter2 :
                            'a t ->
                            'b t ->
                            f:(key:id ->
                               data:[ `Both of 'a * 'b
                                    | `Left of 'a
                                    | `Right of 'b ] ->
                               unit) ->
                            unit
                          val map : 'a t -> f:('-> 'b) -> 'b t
                          val mapi :
                            'a t -> f:(key:id -> data:'-> 'b) -> 'b t
                          val fold :
                            'a t ->
                            init:'->
                            f:(key:id -> data:'-> '-> 'b) -> 'b
                          val fold_right :
                            'a t ->
                            init:'->
                            f:(key:id -> data:'-> '-> 'b) -> 'b
                          val fold2 :
                            'a t ->
                            'b t ->
                            init:'->
                            f:(key:id ->
                               data:[ `Both of 'a * 'b
                                    | `Left of 'a
                                    | `Right of 'b ] ->
                               '-> 'c) ->
                            'c
                          val filter_keys : 'a t -> f:(id -> bool) -> 'a t
                          val filter : 'a t -> f:('-> bool) -> 'a t
                          val filteri :
                            'a t -> f:(key:id -> data:'-> bool) -> 'a t
                          val filter_map :
                            'a t -> f:('-> 'Option.t) -> 'b t
                          val filter_mapi :
                            'a t ->
                            f:(key:id -> data:'-> 'Option.t) -> 'b t
                          val partition_mapi :
                            'a t ->
                            f:(key:id ->
                               data:'-> [ `Fst of '| `Snd of 'c ]) ->
                            'b t * 'c t
                          val partition_map :
                            'a t ->
                            f:('-> [ `Fst of '| `Snd of 'c ]) ->
                            'b t * 'c t
                          val partitioni_tf :
                            'a t ->
                            f:(key:id -> data:'-> bool) -> 'a t * 'a t
                          val partition_tf :
                            'a t -> f:('-> bool) -> 'a t * 'a t
                          val compare_direct :
                            ('-> '-> int) -> 'a t -> 'a t -> int
                          val equal :
                            ('-> '-> bool) -> 'a t -> 'a t -> bool
                          val keys : 'a t -> id List.t
                          val data : 'a t -> 'List.t
                          val to_alist :
                            ?key_order:[ `Decreasing | `Increasing ] ->
                            'a t -> (id * 'a) List.t
                          val validate :
                            name:(id -> string) ->
                            'Base__.Validate.check ->
                            'a t Base__.Validate.check
                          val merge :
                            'a t ->
                            'b t ->
                            f:(key:id ->
                               [ `Both of 'a * 'b
                               | `Left of 'a
                               | `Right of 'b ] -> 'Option.t) ->
                            'c t
                          val symmetric_diff :
                            'a t ->
                            'a t ->
                            data_equal:('-> '-> bool) ->
                            (id, 'a)
                            Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                            Base__.Sequence.t
                          val min_elt : 'a t -> (id * 'a) Option.t
                          val min_elt_exn : 'a t -> id * 'a
                          val max_elt : 'a t -> (id * 'a) Option.t
                          val max_elt_exn : 'a t -> id * 'a
                          val for_all : 'a t -> f:('-> bool) -> bool
                          val for_alli :
                            'a t -> f:(key:id -> data:'-> bool) -> bool
                          val exists : 'a t -> f:('-> bool) -> bool
                          val existsi :
                            'a t -> f:(key:id -> data:'-> bool) -> bool
                          val count : 'a t -> f:('-> bool) -> int
                          val counti :
                            'a t -> f:(key:id -> data:'-> bool) -> int
                          val split :
                            'a t -> id -> 'a t * (id * 'a) Option.t * 'a t
                          val append :
                            lower_part:'a t ->
                            upper_part:'a t ->
                            [ `Ok of 'a t | `Overlapping_key_ranges ]
                          val subrange :
                            'a t ->
                            lower_bound:id Base__.Maybe_bound.t ->
                            upper_bound:id Base__.Maybe_bound.t -> 'a t
                          val fold_range_inclusive :
                            'a t ->
                            min:id ->
                            max:id ->
                            init:'->
                            f:(key:id -> data:'-> '-> 'b) -> 'b
                          val range_to_alist :
                            'a t -> min:id -> max:id -> (id * 'a) List.t
                          val closest_key :
                            'a t ->
                            [ `Greater_or_equal_to
                            | `Greater_than
                            | `Less_or_equal_to
                            | `Less_than ] -> id -> (id * 'a) Option.t
                          val nth : 'a t -> int -> (id * 'a) Option.t
                          val nth_exn : 'a t -> int -> id * 'a
                          val rank : 'a t -> id -> int Option.t
                          val to_tree : 'a t -> 'a t
                          val to_sequence :
                            ?order:[ `Decreasing_key | `Increasing_key ] ->
                            ?keys_greater_or_equal_to:id ->
                            ?keys_less_or_equal_to:id ->
                            'a t -> (id * 'a) Base__.Sequence.t
                          val obs :
                            id Core_kernel__.Quickcheck.Observer.t ->
                            'Core_kernel__.Quickcheck.Observer.t ->
                            'v t Core_kernel__.Quickcheck.Observer.t
                          val shrinker :
                            id Core_kernel__.Quickcheck.Shrinker.t ->
                            'Core_kernel__.Quickcheck.Shrinker.t ->
                            'v t Core_kernel__.Quickcheck.Shrinker.t
                          module Provide_of_sexp :
                            functor
                              (K : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> id
                                   end->
                              sig
                                val t_of_sexp :
                                  (Sexplib.Sexp.t -> 'v_x__017_) ->
                                  Sexplib.Sexp.t -> 'v_x__017_ t
                              end
                          val t_of_sexp :
                            (Base__.Sexplib.Sexp.t -> 'a) ->
                            Base__.Sexplib.Sexp.t -> 'a t
                          val sexp_of_t :
                            ('-> Base__.Sexplib.Sexp.t) ->
                            'a t -> Base__.Sexplib.Sexp.t
                        end
                      type 'a t =
                          (id, 'a, comparator_witness)
                          Core_kernel__.Core_map_intf.Map.t
                      val compare :
                        ('-> '-> Core_kernel__.Import.int) ->
                        'a t -> 'a t -> Core_kernel__.Import.int
                      val empty : 'a t
                      val singleton : id -> '-> 'a t
                      val of_alist :
                        (id * 'a) List.t ->
                        [ `Duplicate_key of id | `Ok of 'a t ]
                      val of_alist_or_error :
                        (id * 'a) List.t -> 'a t Base__.Or_error.t
                      val of_alist_exn : (id * 'a) List.t -> 'a t
                      val of_alist_multi : (id * 'a) List.t -> 'List.t t
                      val of_alist_fold :
                        (id * 'a) List.t ->
                        init:'-> f:('-> '-> 'b) -> 'b t
                      val of_alist_reduce :
                        (id * 'a) List.t -> f:('-> '-> 'a) -> 'a t
                      val of_sorted_array :
                        (id * 'a) array -> 'a t Base__.Or_error.t
                      val of_sorted_array_unchecked : (id * 'a) array -> 'a t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> id * 'a) -> 'a t
                      val of_iteri :
                        iteri:(f:(key:id -> data:'-> unit) -> unit) ->
                        [ `Duplicate_key of id | `Ok of 'v t ]
                      val of_tree : 'Tree.t -> 'a t
                      val of_hashtbl_exn :
                        (id, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                      val gen :
                        id Core_kernel__.Quickcheck.Generator.t ->
                        'Core_kernel__.Quickcheck.Generator.t ->
                        'a t Core_kernel__.Quickcheck.Generator.t
                      val invariants : 'a t -> bool
                      val is_empty : 'a t -> bool
                      val length : 'a t -> int
                      val add : 'a t -> key:id -> data:'-> 'a t
                      val add_multi :
                        'List.t t -> key:id -> data:'-> 'List.t t
                      val remove_multi : 'List.t t -> id -> 'List.t t
                      val change :
                        'a t -> id -> f:('Option.t -> 'Option.t) -> 'a t
                      val update :
                        'a t -> id -> f:('Option.t -> 'a) -> 'a t
                      val find : 'a t -> id -> 'Option.t
                      val find_exn : 'a t -> id -> 'a
                      val remove : 'a t -> id -> 'a t
                      val mem : 'a t -> id -> bool
                      val iter_keys : 'a t -> f:(id -> unit) -> unit
                      val iter : 'a t -> f:('-> unit) -> unit
                      val iteri :
                        'a t -> f:(key:id -> data:'-> unit) -> unit
                      val iter2 :
                        'a t ->
                        'b t ->
                        f:(key:id ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           unit) ->
                        unit
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val mapi : 'a t -> f:(key:id -> data:'-> 'b) -> 'b t
                      val fold :
                        'a t ->
                        init:'-> f:(key:id -> data:'-> '-> 'b) -> 'b
                      val fold_right :
                        'a t ->
                        init:'-> f:(key:id -> data:'-> '-> 'b) -> 'b
                      val fold2 :
                        'a t ->
                        'b t ->
                        init:'->
                        f:(key:id ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           '-> 'c) ->
                        'c
                      val filter_keys : 'a t -> f:(id -> bool) -> 'a t
                      val filter : 'a t -> f:('-> bool) -> 'a t
                      val filteri :
                        'a t -> f:(key:id -> data:'-> bool) -> 'a t
                      val filter_map : 'a t -> f:('-> 'Option.t) -> 'b t
                      val filter_mapi :
                        'a t -> f:(key:id -> data:'-> 'Option.t) -> 'b t
                      val partition_mapi :
                        'a t ->
                        f:(key:id -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                        'b t * 'c t
                      val partition_map :
                        'a t ->
                        f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                      val partitioni_tf :
                        'a t -> f:(key:id -> data:'-> bool) -> 'a t * 'a t
                      val partition_tf :
                        'a t -> f:('-> bool) -> 'a t * 'a t
                      val compare_direct :
                        ('-> '-> int) -> 'a t -> 'a t -> int
                      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                      val keys : 'a t -> id List.t
                      val data : 'a t -> 'List.t
                      val to_alist :
                        ?key_order:[ `Decreasing | `Increasing ] ->
                        'a t -> (id * 'a) List.t
                      val validate :
                        name:(id -> string) ->
                        'Base__.Validate.check ->
                        'a t Base__.Validate.check
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:id ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'Option.t) ->
                        'c t
                      val symmetric_diff :
                        'a t ->
                        'a t ->
                        data_equal:('-> '-> bool) ->
                        (id, 'a)
                        Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                        Base__.Sequence.t
                      val min_elt : 'a t -> (id * 'a) Option.t
                      val min_elt_exn : 'a t -> id * 'a
                      val max_elt : 'a t -> (id * 'a) Option.t
                      val max_elt_exn : 'a t -> id * 'a
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val for_alli :
                        'a t -> f:(key:id -> data:'-> bool) -> bool
                      val exists : 'a t -> f:('-> bool) -> bool
                      val existsi :
                        'a t -> f:(key:id -> data:'-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val counti :
                        'a t -> f:(key:id -> data:'-> bool) -> int
                      val split :
                        'a t -> id -> 'a t * (id * 'a) Option.t * 'a t
                      val append :
                        lower_part:'a t ->
                        upper_part:'a t ->
                        [ `Ok of 'a t | `Overlapping_key_ranges ]
                      val subrange :
                        'a t ->
                        lower_bound:id Base__.Maybe_bound.t ->
                        upper_bound:id Base__.Maybe_bound.t -> 'a t
                      val fold_range_inclusive :
                        'a t ->
                        min:id ->
                        max:id ->
                        init:'-> f:(key:id -> data:'-> '-> 'b) -> 'b
                      val range_to_alist :
                        'a t -> min:id -> max:id -> (id * 'a) List.t
                      val closest_key :
                        'a t ->
                        [ `Greater_or_equal_to
                        | `Greater_than
                        | `Less_or_equal_to
                        | `Less_than ] -> id -> (id * 'a) Option.t
                      val nth : 'a t -> int -> (id * 'a) Option.t
                      val nth_exn : 'a t -> int -> id * 'a
                      val rank : 'a t -> id -> int Option.t
                      val to_tree : 'a t -> 'Tree.t
                      val to_sequence :
                        ?order:[ `Decreasing_key | `Increasing_key ] ->
                        ?keys_greater_or_equal_to:id ->
                        ?keys_less_or_equal_to:id ->
                        'a t -> (id * 'a) Base__.Sequence.t
                      val obs :
                        id Core_kernel__.Quickcheck.Observer.t ->
                        'Core_kernel__.Quickcheck.Observer.t ->
                        'v t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        id Core_kernel__.Quickcheck.Shrinker.t ->
                        'Core_kernel__.Quickcheck.Shrinker.t ->
                        'v t Core_kernel__.Quickcheck.Shrinker.t
                      module Provide_of_sexp :
                        functor
                          (Key : sig val t_of_sexp : Sexplib.Sexp.t -> id end->
                          sig
                            val t_of_sexp :
                              (Sexplib.Sexp.t -> 'v_x__018_) ->
                              Sexplib.Sexp.t -> 'v_x__018_ t
                          end
                      module Provide_bin_io :
                        functor
                          (Key : sig
                                   val bin_t : id Bin_prot.Type_class.t
                                   val bin_read_t : id Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> id)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     id Bin_prot.Type_class.reader
                                   val bin_size_t : id Bin_prot.Size.sizer
                                   val bin_write_t : id Bin_prot.Write.writer
                                   val bin_writer_t :
                                     id Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                          sig
                            val bin_shape_t :
                              Bin_prot.Shape.t -> Bin_prot.Shape.t
                            val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                            val bin_write_t :
                              ('a, 'a t) Bin_prot.Write.writer1
                            val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                            val __bin_read_t__ :
                              ('a, int -> 'a t) Bin_prot.Read.reader1
                            val bin_writer_t :
                              ('a, 'a t) Bin_prot.Type_class.S1.writer
                            val bin_reader_t :
                              ('a, 'a t) Bin_prot.Type_class.S1.reader
                            val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                          end
                      module Provide_hash :
                        functor
                          (Key : sig
                                   val hash_fold_t :
                                     Base__.Hash.state ->
                                     id -> Base__.Hash.state
                                 end->
                          sig
                            val hash_fold_t :
                              (Ppx_hash_lib.Std.Hash.state ->
                               '-> Ppx_hash_lib.Std.Hash.state) ->
                              Ppx_hash_lib.Std.Hash.state ->
                              'a t -> Ppx_hash_lib.Std.Hash.state
                          end
                      val t_of_sexp :
                        (Base__.Sexplib.Sexp.t -> 'a) ->
                        Base__.Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Base__.Sexplib.Sexp.t) ->
                        'a t -> Base__.Sexplib.Sexp.t
                      val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                      val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                      val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                      val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                      val __bin_read_t__ :
                        ('a, int -> 'a t) Bin_prot.Read.reader1
                      val bin_writer_t :
                        ('a, 'a t) Bin_prot.Type_class.S1.writer
                      val bin_reader_t :
                        ('a, 'a t) Bin_prot.Type_class.S1.reader
                      val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                    end
                  module Set :
                    sig
                      module Elt :
                        sig
                          type t = id
                          val bin_t : t Bin_prot.Type_class.t
                          val bin_read_t : t Bin_prot.Read.reader
                          val __bin_read_t__ :
                            (Core_kernel__.Import.int -> t)
                            Bin_prot.Read.reader
                          val bin_reader_t : t Bin_prot.Type_class.reader
                          val bin_size_t : t Bin_prot.Size.sizer
                          val bin_write_t : t Bin_prot.Write.writer
                          val bin_writer_t : t Bin_prot.Type_class.writer
                          val bin_shape_t : Bin_prot.Shape.t
                          val t_of_sexp : Sexplib.Sexp.t -> t
                          val sexp_of_t : t -> Sexplib.Sexp.t
                          type comparator_witness =
                              Map.Key.comparator_witness
                          val comparator :
                            (t, comparator_witness)
                            Core_kernel__.Comparator.comparator
                        end
                      module Tree :
                        sig
                          type t =
                              (id, comparator_witness)
                              Core_kernel__.Core_set_intf.Tree.t
                          val compare : t -> t -> Core_kernel__.Import.int
                          val length : t -> int
                          val is_empty : t -> bool
                          val iter : t -> f:(id -> unit) -> unit
                          val fold :
                            t ->
                            init:'accum ->
                            f:('accum -> id -> 'accum) -> 'accum
                          val fold_result :
                            t ->
                            init:'accum ->
                            f:('accum -> id -> ('accum, 'e) Base__.Result.t) ->
                            ('accum, 'e) Base__.Result.t
                          val exists : t -> f:(id -> bool) -> bool
                          val for_all : t -> f:(id -> bool) -> bool
                          val count : t -> f:(id -> bool) -> int
                          val sum :
                            (module Base__.Commutative_group.S with type t = 'sum) ->
                            t -> f:(id -> 'sum) -> 'sum
                          val find : t -> f:(id -> bool) -> id Option.t
                          val find_map :
                            t -> f:(id -> 'Option.t) -> 'Option.t
                          val to_list : t -> id List.t
                          val to_array : t -> id array
                          val invariants : t -> bool
                          val mem : t -> id -> bool
                          val add : t -> id -> t
                          val remove : t -> id -> t
                          val union : t -> t -> t
                          val inter : t -> t -> t
                          val diff : t -> t -> t
                          val symmetric_diff :
                            t ->
                            t -> (id, id) Base__.Either.t Base__.Sequence.t
                          val compare_direct : t -> t -> int
                          val equal : t -> t -> bool
                          val is_subset : t -> of_:t -> bool
                          val subset : t -> t -> bool
                          val fold_until :
                            t ->
                            init:'->
                            f:('->
                               id ->
                               ('b, 'stop)
                               Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                            ('b, 'stop)
                            Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                          val fold_right :
                            t -> init:'-> f:(id -> '-> 'b) -> 'b
                          val iter2 :
                            t ->
                            t ->
                            f:([ `Both of id * id
                               | `Left of id
                               | `Right of id ] -> unit) ->
                            unit
                          val filter : t -> f:(id -> bool) -> t
                          val partition_tf : t -> f:(id -> bool) -> t * t
                          val elements : t -> id List.t
                          val min_elt : t -> id Option.t
                          val min_elt_exn : t -> id
                          val max_elt : t -> id Option.t
                          val max_elt_exn : t -> id
                          val choose : t -> id Option.t
                          val choose_exn : t -> id
                          val split : t -> id -> t * id Option.t * t
                          val group_by :
                            t -> equiv:(id -> id -> bool) -> t List.t
                          val find_exn : t -> f:(id -> bool) -> id
                          val find_index : t -> int -> id Option.t
                          val nth : t -> int -> id Option.t
                          val remove_index : t -> int -> t
                          val to_tree : t -> t
                          val to_sequence :
                            ?order:[ `Decreasing | `Increasing ] ->
                            ?greater_or_equal_to:id ->
                            ?less_or_equal_to:id -> t -> id Base__.Sequence.t
                          val merge_to_sequence :
                            ?order:[ `Decreasing | `Increasing ] ->
                            ?greater_or_equal_to:id ->
                            ?less_or_equal_to:id ->
                            t ->
                            t ->
                            (id, id)
                            Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                            Base__.Sequence.t
                          val to_map :
                            t ->
                            f:(id -> 'data) ->
                            (id, 'data, comparator_witness)
                            Core_kernel__.Core_set_intf.Map.t
                          val obs :
                            id Core_kernel__.Quickcheck.Observer.t ->
                            t Core_kernel__.Quickcheck.Observer.t
                          val shrinker :
                            id Core_kernel__.Quickcheck.Shrinker.t ->
                            t Core_kernel__.Quickcheck.Shrinker.t
                          val empty : t
                          val singleton : id -> t
                          val union_list : t List.t -> t
                          val of_list : id List.t -> t
                          val of_array : id array -> t
                          val of_sorted_array :
                            id array -> t Base__.Or_error.t
                          val of_sorted_array_unchecked : id array -> t
                          val of_increasing_iterator_unchecked :
                            len:int -> f:(int -> id) -> t
                          val stable_dedup_list : id List.t -> id List.t
                          val map :
                            ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                            f:('-> id) -> t
                          val filter_map :
                            ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                            f:('-> id Option.t) -> t
                          val of_tree : t -> t
                          val of_hash_set : id Core_kernel__.Hash_set.t -> t
                          val of_hashtbl_keys :
                            (id, 'a) Core_kernel__.Core_hashtbl.t -> t
                          val of_map_keys :
                            (id, 'a, comparator_witness)
                            Core_kernel__.Core_set_intf.Map.t -> t
                          val gen :
                            id Core_kernel__.Quickcheck.Generator.t ->
                            t Core_kernel__.Quickcheck.Generator.t
                          module Provide_of_sexp :
                            functor
                              (Elt : sig
                                       val t_of_sexp : Sexplib.Sexp.t -> id
                                     end->
                              sig val t_of_sexp : Sexplib.Sexp.t -> t end
                          val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                          val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                        end
                      type t = (id, comparator_witness) Base.Set.t
                      val compare : t -> t -> Core_kernel__.Import.int
                      val length : t -> int
                      val is_empty : t -> bool
                      val iter : t -> f:(id -> unit) -> unit
                      val fold :
                        t ->
                        init:'accum -> f:('accum -> id -> 'accum) -> 'accum
                      val fold_result :
                        t ->
                        init:'accum ->
                        f:('accum -> id -> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val exists : t -> f:(id -> bool) -> bool
                      val for_all : t -> f:(id -> bool) -> bool
                      val count : t -> f:(id -> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        t -> f:(id -> 'sum) -> 'sum
                      val find : t -> f:(id -> bool) -> id Option.t
                      val find_map :
                        t -> f:(id -> 'Option.t) -> 'Option.t
                      val to_list : t -> id List.t
                      val to_array : t -> id array
                      val invariants : t -> bool
                      val mem : t -> id -> bool
                      val add : t -> id -> t
                      val remove : t -> id -> t
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val symmetric_diff :
                        t -> t -> (id, id) Base__.Either.t Base__.Sequence.t
                      val compare_direct : t -> t -> int
                      val equal : t -> t -> bool
                      val is_subset : t -> of_:t -> bool
                      val subset : t -> t -> bool
                      val fold_until :
                        t ->
                        init:'->
                        f:('->
                           id ->
                           ('b, 'stop)
                           Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                        ('b, 'stop)
                        Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                      val fold_right :
                        t -> init:'-> f:(id -> '-> 'b) -> 'b
                      val iter2 :
                        t ->
                        t ->
                        f:([ `Both of id * id | `Left of id | `Right of id ] ->
                           unit) ->
                        unit
                      val filter : t -> f:(id -> bool) -> t
                      val partition_tf : t -> f:(id -> bool) -> t * t
                      val elements : t -> id List.t
                      val min_elt : t -> id Option.t
                      val min_elt_exn : t -> id
                      val max_elt : t -> id Option.t
                      val max_elt_exn : t -> id
                      val choose : t -> id Option.t
                      val choose_exn : t -> id
                      val split : t -> id -> t * id Option.t * t
                      val group_by :
                        t -> equiv:(id -> id -> bool) -> t List.t
                      val find_exn : t -> f:(id -> bool) -> id
                      val find_index : t -> int -> id Option.t
                      val nth : t -> int -> id Option.t
                      val remove_index : t -> int -> t
                      val to_tree : t -> Tree.t
                      val to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:id ->
                        ?less_or_equal_to:id -> t -> id Base__.Sequence.t
                      val merge_to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:id ->
                        ?less_or_equal_to:id ->
                        t ->
                        t ->
                        (id, id)
                        Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                        Base__.Sequence.t
                      val to_map :
                        t ->
                        f:(id -> 'data) ->
                        (id, 'data, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t
                      val obs :
                        id Core_kernel__.Quickcheck.Observer.t ->
                        t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        id Core_kernel__.Quickcheck.Shrinker.t ->
                        t Core_kernel__.Quickcheck.Shrinker.t
                      val empty : t
                      val singleton : id -> t
                      val union_list : t List.t -> t
                      val of_list : id List.t -> t
                      val of_array : id array -> t
                      val of_sorted_array : id array -> t Base__.Or_error.t
                      val of_sorted_array_unchecked : id array -> t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> id) -> t
                      val stable_dedup_list : id List.t -> id List.t
                      val map : ('a, 'b) Base.Set.t -> f:('-> id) -> t
                      val filter_map :
                        ('a, 'b) Base.Set.t -> f:('-> id Option.t) -> t
                      val of_tree : Tree.t -> t
                      val of_hash_set : id Core_kernel__.Hash_set.t -> t
                      val of_hashtbl_keys :
                        (id, 'a) Core_kernel__.Core_hashtbl.t -> t
                      val of_map_keys :
                        (id, 'a, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t -> t
                      val gen :
                        id Core_kernel__.Quickcheck.Generator.t ->
                        t Core_kernel__.Quickcheck.Generator.t
                      module Provide_of_sexp :
                        functor
                          (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> id end->
                          sig val t_of_sexp : Sexplib.Sexp.t -> t end
                      module Provide_bin_io :
                        functor
                          (Elt : sig
                                   val bin_t : id Bin_prot.Type_class.t
                                   val bin_read_t : id Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> id)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     id Bin_prot.Type_class.reader
                                   val bin_size_t : id Bin_prot.Size.sizer
                                   val bin_write_t : id Bin_prot.Write.writer
                                   val bin_writer_t :
                                     id Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                          sig
                            val bin_size_t : t Bin_prot.Size.sizer
                            val bin_write_t : t Bin_prot.Write.writer
                            val bin_read_t : t Bin_prot.Read.reader
                            val __bin_read_t__ :
                              (int -> t) Bin_prot.Read.reader
                            val bin_shape_t : Bin_prot.Shape.t
                            val bin_writer_t : t Bin_prot.Type_class.writer
                            val bin_reader_t : t Bin_prot.Type_class.reader
                            val bin_t : t Bin_prot.Type_class.t
                          end
                      module Provide_hash :
                        functor
                          (Elt : sig
                                   val hash_fold_t :
                                     Base__.Hash.state ->
                                     id -> Base__.Hash.state
                                 end->
                          sig
                            val hash_fold_t :
                              Ppx_hash_lib.Std.Hash.state ->
                              t -> Ppx_hash_lib.Std.Hash.state
                            val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                          end
                      val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                      val bin_shape_t : Bin_prot.Shape.t
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_t : t Bin_prot.Type_class.t
                    end
                  val hash : t -> Core_kernel__.Import.int
                  val hashable : t Core_kernel__.Hashable.Hashtbl.Hashable.t
                  module Table :
                    sig
                      type key = t
                      type ('a, 'b) hashtbl = ('a, 'b) Id.Table.hashtbl
                      type 'b t = (key, 'b) hashtbl
                      val sexp_of_t :
                        ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                      type ('a, 'b) t_ = 'b t
                      type 'a key_ = key
                      val hashable :
                        key Core_kernel__.Core_hashtbl_intf.Hashable.t
                      val invariant :
                        'Base__.Invariant_intf.inv ->
                        'a t Base__.Invariant_intf.inv
                      val create :
                        (key, 'b, unit -> 'b t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist :
                        (key, 'b,
                         (key * 'b) List.t ->
                         [ `Duplicate_key of key | `Ok of 'b t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_report_all_dups :
                        (key, 'b,
                         (key * 'b) List.t ->
                         [ `Duplicate_keys of key List.t | `Ok of 'b t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_or_error :
                        (key, 'b,
                         (key * 'b) List.t -> 'b t Base__.Or_error.t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_exn :
                        (key, 'b, (key * 'b) List.t -> 'b t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_multi :
                        (key, 'List.t, (key * 'b) List.t -> 'List.t t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_mapped :
                        (key, 'b,
                         get_key:('-> key) ->
                         get_data:('-> 'b) ->
                         'List.t ->
                         [ `Duplicate_keys of key List.t | `Ok of 'b t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_with_key :
                        (key, 'r,
                         get_key:('-> key) ->
                         'List.t ->
                         [ `Duplicate_keys of key List.t | `Ok of 'r t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_with_key_or_error :
                        (key, 'r,
                         get_key:('-> key) ->
                         'List.t -> 'r t Base__.Or_error.t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_with_key_exn :
                        (key, 'r, get_key:('-> key) -> 'List.t -> 'r t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val group :
                        (key, 'b,
                         get_key:('-> key) ->
                         get_data:('-> 'b) ->
                         combine:('-> '-> 'b) -> 'List.t -> 'b t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                      val clear : 'a t -> unit
                      val copy : 'b t -> 'b t
                      val fold :
                        'b t ->
                        init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                      val iter_keys : 'a t -> f:(key -> unit) -> unit
                      val iter : 'b t -> f:('-> unit) -> unit
                      val iteri :
                        'b t -> f:(key:key -> data:'-> unit) -> unit
                      val iter_vals : 'b t -> f:('-> unit) -> unit
                      val existsi :
                        'b t -> f:(key:key -> data:'-> bool) -> bool
                      val exists : 'b t -> f:('-> bool) -> bool
                      val for_alli :
                        'b t -> f:(key:key -> data:'-> bool) -> bool
                      val for_all : 'b t -> f:('-> bool) -> bool
                      val counti :
                        'b t -> f:(key:key -> data:'-> bool) -> int
                      val count : 'b t -> f:('-> bool) -> int
                      val length : 'a t -> int
                      val is_empty : 'a t -> bool
                      val mem : 'a t -> key -> bool
                      val remove : 'a t -> key -> unit
                      val replace : 'b t -> key:key -> data:'-> unit
                      val set : 'b t -> key:key -> data:'-> unit
                      val add :
                        'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                      val add_or_error :
                        'b t -> key:key -> data:'-> unit Base__.Or_error.t
                      val add_exn : 'b t -> key:key -> data:'-> unit
                      val change :
                        'b t -> key -> f:('Option.t -> 'Option.t) -> unit
                      val update :
                        'b t -> key -> f:('Option.t -> 'b) -> unit
                      val add_multi :
                        'List.t t -> key:key -> data:'-> unit
                      val remove_multi : 'List.t t -> key -> unit
                      val map : 'b t -> f:('-> 'c) -> 'c t
                      val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                      val filter_map : 'b t -> f:('-> 'Option.t) -> 'c t
                      val filter_mapi :
                        'b t -> f:(key:key -> data:'-> 'Option.t) -> 'c t
                      val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                      val filter : 'b t -> f:('-> bool) -> 'b t
                      val filteri :
                        'b t -> f:(key:key -> data:'-> bool) -> 'b t
                      val partition_map :
                        'b t ->
                        f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
                      val partition_mapi :
                        'b t ->
                        f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                        'c t * 'd t
                      val partition_tf :
                        'b t -> f:('-> bool) -> 'b t * 'b t
                      val partitioni_tf :
                        'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
                      val find_or_add :
                        'b t -> key -> default:(unit -> 'b) -> 'b
                      val find : 'b t -> key -> 'Option.t
                      val find_exn : 'b t -> key -> 'b
                      val find_and_call :
                        'b t ->
                        key ->
                        if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
                      val find_and_remove : 'b t -> key -> 'Option.t
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:key ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'Option.t) ->
                        'c t
                      type 'a merge_into_action = Remove | Set_to of 'a
                      val merge_into :
                        src:'a t ->
                        dst:'b t ->
                        f:(key:key ->
                           '-> 'Option.t -> 'b merge_into_action) ->
                        unit
                      val keys : 'a t -> key List.t
                      val data : 'b t -> 'List.t
                      val filter_keys_inplace :
                        'a t -> f:(key -> bool) -> unit
                      val filter_inplace : 'b t -> f:('-> bool) -> unit
                      val filteri_inplace :
                        'b t -> f:(key:key -> data:'-> bool) -> unit
                      val map_inplace : 'b t -> f:('-> 'b) -> unit
                      val mapi_inplace :
                        'b t -> f:(key:key -> data:'-> 'b) -> unit
                      val filter_map_inplace :
                        'b t -> f:('-> 'Option.t) -> unit
                      val filter_mapi_inplace :
                        'b t -> f:(key:key -> data:'-> 'Option.t) -> unit
                      val replace_all : 'b t -> f:('-> 'b) -> unit
                      val replace_alli :
                        'b t -> f:(key:key -> data:'-> 'b) -> unit
                      val filter_replace_all :
                        'b t -> f:('-> 'Option.t) -> unit
                      val filter_replace_alli :
                        'b t -> f:(key:key -> data:'-> 'Option.t) -> unit
                      val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
                      val similar :
                        'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                      val to_alist : 'b t -> (key * 'b) List.t
                      val validate :
                        name:(key -> string) ->
                        'Base__.Validate.check ->
                        'b t Base__.Validate.check
                      val incr :
                        ?by:int ->
                        ?remove_if_zero:bool -> int t -> key -> unit
                      val decr :
                        ?by:int ->
                        ?remove_if_zero:bool -> int t -> key -> unit
                      module Provide_of_sexp :
                        functor
                          (Key : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> key
                                 end->
                          sig
                            val t_of_sexp :
                              (Sexplib.Sexp.t -> 'v_x__001_) ->
                              Sexplib.Sexp.t -> 'v_x__001_ t
                          end
                      module Provide_bin_io :
                        functor
                          (Key : sig
                                   val bin_t : key Bin_prot.Type_class.t
                                   val bin_read_t : key Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> key)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     key Bin_prot.Type_class.reader
                                   val bin_size_t : key Bin_prot.Size.sizer
                                   val bin_write_t :
                                     key Bin_prot.Write.writer
                                   val bin_writer_t :
                                     key Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                          sig
                            val bin_t :
                              'Bin_prot.Type_class.t ->
                              'a t Bin_prot.Type_class.t
                            val bin_read_t :
                              'Bin_prot.Read.reader ->
                              'a t Bin_prot.Read.reader
                            val __bin_read_t__ :
                              'Bin_prot.Read.reader ->
                              (Core_kernel__.Import.int -> 'a t)
                              Bin_prot.Read.reader
                            val bin_reader_t :
                              'Bin_prot.Type_class.reader ->
                              'a t Bin_prot.Type_class.reader
                            val bin_size_t :
                              'Bin_prot.Size.sizer ->
                              'a t Bin_prot.Size.sizer
                            val bin_write_t :
                              'Bin_prot.Write.writer ->
                              'a t Bin_prot.Write.writer
                            val bin_writer_t :
                              'Bin_prot.Type_class.writer ->
                              'a t Bin_prot.Type_class.writer
                            val bin_shape_t :
                              Bin_prot.Shape.t -> Bin_prot.Shape.t
                          end
                      val t_of_sexp :
                        (Sexplib.Sexp.t -> 'v_x__002_) ->
                        Sexplib.Sexp.t -> 'v_x__002_ t
                      val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                      val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                      val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                      val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                      val __bin_read_t__ :
                        ('a, int -> 'a t) Bin_prot.Read.reader1
                      val bin_writer_t :
                        ('a, 'a t) Bin_prot.Type_class.S1.writer
                      val bin_reader_t :
                        ('a, 'a t) Bin_prot.Type_class.S1.reader
                      val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                    end
                  module Hash_set :
                    sig
                      type elt = t
                      type t = elt Core_kernel__.Hash_set.t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      type 'a t_ = t
                      type 'a elt_ = elt
                      val create :
                        ('a, unit -> t)
                        Core_kernel__.Hash_set_intf.create_options_without_hashable
                      val of_list :
                        ('a, elt List.t -> t)
                        Core_kernel__.Hash_set_intf.create_options_without_hashable
                      module Provide_of_sexp :
                        functor
                          (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                          sig val t_of_sexp : Sexplib.Sexp.t -> t end
                      module Provide_bin_io :
                        functor
                          (X : sig
                                 val bin_t : elt Bin_prot.Type_class.t
                                 val bin_read_t : elt Bin_prot.Read.reader
                                 val __bin_read_t__ :
                                   (Core_kernel__.Import.int -> elt)
                                   Bin_prot.Read.reader
                                 val bin_reader_t :
                                   elt Bin_prot.Type_class.reader
                                 val bin_size_t : elt Bin_prot.Size.sizer
                                 val bin_write_t : elt Bin_prot.Write.writer
                                 val bin_writer_t :
                                   elt Bin_prot.Type_class.writer
                                 val bin_shape_t : Bin_prot.Shape.t
                               end->
                          sig
                            val bin_t : t Bin_prot.Type_class.t
                            val bin_read_t : t Bin_prot.Read.reader
                            val __bin_read_t__ :
                              (Core_kernel__.Import.int -> t)
                              Bin_prot.Read.reader
                            val bin_reader_t : t Bin_prot.Type_class.reader
                            val bin_size_t : t Bin_prot.Size.sizer
                            val bin_write_t : t Bin_prot.Write.writer
                            val bin_writer_t : t Bin_prot.Type_class.writer
                            val bin_shape_t : Bin_prot.Shape.t
                          end
                      val t_of_sexp : Sexplib.Sexp.t -> t
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                      val bin_shape_t : Bin_prot.Shape.t
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_t : t Bin_prot.Type_class.t
                    end
                  module Hash_queue :
                    sig
                      module Key :
                        sig
                          type t = id
                          val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                          val compare : t -> t -> int
                          val hash : t -> int
                        end
                      type 'a t
                      val sexp_of_t :
                        ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                      val length : 'a t -> int
                      val is_empty : 'a t -> bool
                      val iter : 'a t -> f:('-> unit) -> unit
                      val fold :
                        'a t ->
                        init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                      val fold_result :
                        'a t ->
                        init:'accum ->
                        f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val fold_until :
                        'a t ->
                        init:'accum ->
                        f:('accum ->
                           '->
                           ('accum, 'stop)
                           Base.Container_intf.Continue_or_stop.t) ->
                        ('accum, 'stop)
                        Base.Container_intf.Finished_or_stopped_early.t
                      val exists : 'a t -> f:('-> bool) -> bool
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        'a t -> f:('-> 'sum) -> 'sum
                      val find : 'a t -> f:('-> bool) -> 'Option.t
                      val find_map :
                        'a t -> f:('-> 'Option.t) -> 'Option.t
                      val to_list : 'a t -> 'List.t
                      val to_array : 'a t -> 'a array
                      val min_elt :
                        'a t -> cmp:('-> '-> int) -> 'Option.t
                      val max_elt :
                        'a t -> cmp:('-> '-> int) -> 'Option.t
                      val invariant : 'a t -> Core_kernel__.Import.unit
                      val create :
                        ?growth_allowed:Core_kernel__.Import.bool ->
                        ?size:Core_kernel__.Import.int ->
                        Core_kernel__.Import.unit -> 'a t
                      val clear : 'a t -> Core_kernel__.Import.unit
                      val mem : 'a t -> id -> Core_kernel__.Import.bool
                      val lookup :
                        'a t -> id -> 'Core_kernel__.Import.option
                      val lookup_exn : 'a t -> id -> 'a
                      val enqueue :
                        'a t -> id -> '-> [ `Key_already_present | `Ok ]
                      val enqueue_exn :
                        'a t -> id -> '-> Core_kernel__.Import.unit
                      val lookup_and_move_to_back :
                        'a t -> id -> 'Core_kernel__.Import.option
                      val lookup_and_move_to_back_exn : 'a t -> id -> 'a
                      val first : 'a t -> 'Core_kernel__.Import.option
                      val first_with_key :
                        'a t -> (id * 'a) Core_kernel__.Import.option
                      val keys : 'a t -> id Core_kernel__.Import.list
                      val dequeue : 'a t -> 'Core_kernel__.Import.option
                      val dequeue_exn : 'a t -> 'a
                      val dequeue_with_key :
                        'a t -> (id * 'a) Core_kernel__.Import.option
                      val dequeue_with_key_exn : 'a t -> id * 'a
                      val dequeue_all :
                        'a t ->
                        f:('-> Core_kernel__.Import.unit) ->
                        Core_kernel__.Import.unit
                      val remove : 'a t -> id -> [ `No_such_key | `Ok ]
                      val remove_exn :
                        'a t -> id -> Core_kernel__.Import.unit
                      val replace :
                        'a t -> id -> '-> [ `No_such_key | `Ok ]
                      val replace_exn :
                        'a t -> id -> '-> Core_kernel__.Import.unit
                      val iteri :
                        'a t ->
                        f:(key:id -> data:'-> Core_kernel__.Import.unit) ->
                        Core_kernel__.Import.unit
                      val foldi :
                        'a t ->
                        init:'-> f:('-> key:id -> data:'-> 'b) -> 'b
                    end
                  val pp : Base__.Import.Caml.Format.formatter -> t -> unit
                end
              val global : Monads.Std.Monad.State.Multi.S.id
              val fork : unit -> unit t
              val switch : Monads.Std.Monad.State.Multi.S.id -> unit t
              val parent : unit -> Monads.Std.Monad.State.Multi.S.id t
              val ancestor :
                Monads.Std.Monad.State.Multi.S.id list ->
                Monads.Std.Monad.State.Multi.S.id t
              val current : unit -> Monads.Std.Monad.State.Multi.S.id t
              val kill : Monads.Std.Monad.State.Multi.S.id -> unit t
              val forks :
                unit ->
                Monads.Std.Monad.State.Multi.S.id Core_kernel.Std.Sequence.t
                t
              val status :
                Monads.Std.Monad.State.Multi.S.id ->
                Monads.Std.Monad.State.Multi.status t
              val lift : 'a m -> 'a t
              val run : 'a t -> 'a e
              val void : 'a t -> unit t
              val sequence : unit t List.t -> unit t
              val forever : 'a t -> 'b t
              module Fn :
                sig
                  val id : '-> 'a t
                  val ignore : 'a t -> unit t
                  val nothing : unit -> unit t
                  val non : ('-> bool t) -> '-> bool t
                  val apply_n_times : n:int -> ('-> 'a t) -> '-> 'a t
                  val compose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
                end
              module Pair :
                sig
                  val fst : ('a * 'b) t -> 'a t
                  val snd : ('a * 'b) t -> 'b t
                end
              module Triple :
                sig
                  val fst : ('a * 'b * 'c) t -> 'a t
                  val snd : ('a * 'b * 'c) t -> 'b t
                  val trd : ('a * 'b * 'c) t -> 'c t
                end
              module Lift :
                sig
                  val nullary : '-> 'a t
                  val unary : ('-> 'b) -> 'a t -> 'b t
                  val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ternary :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val quaternary :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val quinary :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                end
              module Exn :
                sig
                  val expect :
                    ?finally:(unit -> unit t) ->
                    f:(unit -> 'a t) -> catch:(exn -> 'a t) -> 'a t
                end
              module Collection :
                sig
                  module type S =
                    sig
                      type 'a t
                      val all : 'a t t -> 'a t t
                      val all_ignore : 'a t t -> unit t
                      val sequence : unit t t -> unit t
                      val map : 'a t -> f:('-> 'b t) -> 'b t t
                      val iter : 'a t -> f:('-> unit t) -> unit t
                      val fold :
                        'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'a t -> f:('-> '-> 'a t) -> 'Option.t t
                      val exists : 'a t -> f:('-> bool t) -> bool t
                      val for_all : 'a t -> f:('-> bool t) -> bool t
                      val count : 'a t -> f:('-> bool t) -> int t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b t -> f:('-> 'a t) -> 'a t
                      val find : 'a t -> f:('-> bool t) -> 'Option.t t
                      val find_map :
                        'a t -> f:('-> 'Option.t t) -> 'Option.t t
                      val filter : 'a t -> f:('-> bool t) -> 'a t t
                      val filter_map :
                        'a t -> f:('-> 'Option.t t) -> 'b t t
                    end
                  module Eager :
                    functor (T : Collection.Eager->
                      sig
                        val all : 'a t T.t -> 'T.t t
                        val all_ignore : 'a t T.t -> unit t
                        val sequence : unit t T.t -> unit t
                        val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                        val iter : 'T.t -> f:('-> unit t) -> unit t
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_right :
                          'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                        val reduce :
                          'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                        val exists : 'T.t -> f:('-> bool t) -> bool t
                        val for_all : 'T.t -> f:('-> bool t) -> bool t
                        val count : 'T.t -> f:('-> bool t) -> int t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a t) -> 'a t
                        val find :
                          'T.t -> f:('-> bool t) -> 'Option.t t
                        val find_map :
                          'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                        val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                        val filter_map :
                          'T.t -> f:('-> 'Option.t t) -> 'T.t t
                      end
                  module Delay :
                    functor (T : Collection.Delay->
                      sig
                        val all : 'a t T.t -> 'T.t t
                        val all_ignore : 'a t T.t -> unit t
                        val sequence : unit t T.t -> unit t
                        val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                        val iter : 'T.t -> f:('-> unit t) -> unit t
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_right :
                          'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                        val reduce :
                          'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                        val exists : 'T.t -> f:('-> bool t) -> bool t
                        val for_all : 'T.t -> f:('-> bool t) -> bool t
                        val count : 'T.t -> f:('-> bool t) -> int t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a t) -> 'a t
                        val find :
                          'T.t -> f:('-> bool t) -> 'Option.t t
                        val find_map :
                          'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                        val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                        val filter_map :
                          'T.t -> f:('-> 'Option.t t) -> 'T.t t
                      end
                end
              module List :
                sig
                  val all : 'a t List.t -> 'List.t t
                  val all_ignore : 'a t List.t -> unit t
                  val sequence : unit t List.t -> unit t
                  val map : 'List.t -> f:('-> 'b t) -> 'List.t t
                  val iter : 'List.t -> f:('-> unit t) -> unit t
                  val fold :
                    'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'List.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce :
                    'List.t -> f:('-> '-> 'a t) -> 'Option.t t
                  val exists : 'List.t -> f:('-> bool t) -> bool t
                  val for_all : 'List.t -> f:('-> bool t) -> bool t
                  val count : 'List.t -> f:('-> bool t) -> int t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'List.t -> f:('-> 'a t) -> 'a t
                  val find : 'List.t -> f:('-> bool t) -> 'Option.t t
                  val find_map :
                    'List.t -> f:('-> 'Option.t t) -> 'Option.t t
                  val filter : 'List.t -> f:('-> bool t) -> 'List.t t
                  val filter_map :
                    'List.t -> f:('-> 'Option.t t) -> 'List.t t
                end
              module Seq :
                sig
                  val all : 'a t Seq.t -> 'Seq.t t
                  val all_ignore : 'a t Seq.t -> unit t
                  val sequence : unit t Seq.t -> unit t
                  val map : 'Seq.t -> f:('-> 'b t) -> 'Seq.t t
                  val iter : 'Seq.t -> f:('-> unit t) -> unit t
                  val fold :
                    'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'Seq.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce :
                    'Seq.t -> f:('-> '-> 'a t) -> 'Option.t t
                  val exists : 'Seq.t -> f:('-> bool t) -> bool t
                  val for_all : 'Seq.t -> f:('-> bool t) -> bool t
                  val count : 'Seq.t -> f:('-> bool t) -> int t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'Seq.t -> f:('-> 'a t) -> 'a t
                  val find : 'Seq.t -> f:('-> bool t) -> 'Option.t t
                  val find_map :
                    'Seq.t -> f:('-> 'Option.t t) -> 'Option.t t
                  val filter : 'Seq.t -> f:('-> bool t) -> 'Seq.t t
                  val filter_map :
                    'Seq.t -> f:('-> 'Option.t t) -> 'Seq.t t
                end
              val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
              val ( !! ) : '-> 'a t
              val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
              val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              module Monad_infix :
                sig
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                end
              val bind : 'a t -> f:('-> 'b t) -> 'b t
              val return : '-> 'a t
              val map : 'a t -> f:('-> 'b) -> 'b t
              val join : 'a t t -> 'a t
              val ignore_m : 'a t -> unit t
              val all : 'a t list -> 'a list t
              val all_ignore : unit t list -> unit t
              module Let_syntax :
                sig
                  val return : '-> 'a t
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  module Let_syntax :
                    sig
                      val return : '-> 'a t
                      val bind : 'a t -> f:('-> 'b t) -> 'b t
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val both : 'a t -> 'b t -> ('a * 'b) t
                      module Open_on_rhs : sig  end
                    end
                end
              module Syntax :
                sig
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                  val ( !! ) : '-> 'a t
                  val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                  val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                end
              type env
              val put : env -> unit t
              val get : unit -> env t
              val gets : (env -> 'r) -> 'r t
              val update : (env -> env) -> unit t
            end
          module type S2 =
            sig
              type ('a, 'e) t
              type 'a m
              type ('a, 'e) e
              type id
              module Id :
                sig
                  type t = id
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  val of_string : string -> t
                  val to_string : t -> string
                  val ( >= ) : t -> t -> bool
                  val ( <= ) : t -> t -> bool
                  val ( = ) : t -> t -> bool
                  val ( > ) : t -> t -> bool
                  val ( < ) : t -> t -> bool
                  val ( <> ) : t -> t -> bool
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val min : t -> t -> t
                  val max : t -> t -> t
                  val ascending : t -> t -> int
                  val descending : t -> t -> int
                  val between : t -> low:t -> high:t -> bool
                  val clamp_exn : t -> min:t -> max:t -> t
                  val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
                  type comparator_witness
                  val validate_lbound :
                    min:t Base__.Maybe_bound.t -> t Base__.Validate.check
                  val validate_ubound :
                    max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                  val validate_bound :
                    min:t Base__.Maybe_bound.t ->
                    max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                  module Replace_polymorphic_compare :
                    sig
                      val ( >= ) : t -> t -> bool
                      val ( <= ) : t -> t -> bool
                      val ( = ) : t -> t -> bool
                      val ( > ) : t -> t -> bool
                      val ( < ) : t -> t -> bool
                      val ( <> ) : t -> t -> bool
                      val equal : t -> t -> bool
                      val compare : t -> t -> int
                      val min : t -> t -> t
                      val max : t -> t -> t
                    end
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                  module Map :
                    sig
                      module Key :
                        sig
                          type t = id
                          val t_of_sexp : Sexplib.Sexp.t -> t
                          val sexp_of_t : t -> Sexplib.Sexp.t
                          val bin_t : t Bin_prot.Type_class.t
                          val bin_read_t : t Bin_prot.Read.reader
                          val __bin_read_t__ :
                            (Core_kernel__.Import.int -> t)
                            Bin_prot.Read.reader
                          val bin_reader_t : t Bin_prot.Type_class.reader
                          val bin_size_t : t Bin_prot.Size.sizer
                          val bin_write_t : t Bin_prot.Write.writer
                          val bin_writer_t : t Bin_prot.Type_class.writer
                          val bin_shape_t : Bin_prot.Shape.t
                          type comparator_witness = comparator_witness
                          val comparator :
                            (t, comparator_witness)
                            Core_kernel__.Comparator.comparator
                        end
                      module Tree :
                        sig
                          type 'a t =
                              (id, 'a, comparator_witness)
                              Core_kernel__.Core_map_intf.Tree.t
                          val empty : 'a t
                          val singleton : id -> '-> 'a t
                          val of_alist :
                            (id * 'a) List.t ->
                            [ `Duplicate_key of id | `Ok of 'a t ]
                          val of_alist_or_error :
                            (id * 'a) List.t -> 'a t Base__.Or_error.t
                          val of_alist_exn : (id * 'a) List.t -> 'a t
                          val of_alist_multi :
                            (id * 'a) List.t -> 'List.t t
                          val of_alist_fold :
                            (id * 'a) List.t ->
                            init:'-> f:('-> '-> 'b) -> 'b t
                          val of_alist_reduce :
                            (id * 'a) List.t -> f:('-> '-> 'a) -> 'a t
                          val of_sorted_array :
                            (id * 'a) array -> 'a t Base__.Or_error.t
                          val of_sorted_array_unchecked :
                            (id * 'a) array -> 'a t
                          val of_increasing_iterator_unchecked :
                            len:int -> f:(int -> id * 'a) -> 'a t
                          val of_iteri :
                            iteri:(f:(key:id -> data:'-> unit) -> unit) ->
                            [ `Duplicate_key of id | `Ok of 'v t ]
                          val of_tree : 'a t -> 'a t
                          val of_hashtbl_exn :
                            (id, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                          val gen :
                            id Core_kernel__.Quickcheck.Generator.t ->
                            'Core_kernel__.Quickcheck.Generator.t ->
                            'a t Core_kernel__.Quickcheck.Generator.t
                          val invariants : 'a t -> bool
                          val is_empty : 'a t -> bool
                          val length : 'a t -> int
                          val add : 'a t -> key:id -> data:'-> 'a t
                          val add_multi :
                            'List.t t -> key:id -> data:'-> 'List.t t
                          val remove_multi : 'List.t t -> id -> 'List.t t
                          val change :
                            'a t ->
                            id -> f:('Option.t -> 'Option.t) -> 'a t
                          val update :
                            'a t -> id -> f:('Option.t -> 'a) -> 'a t
                          val find : 'a t -> id -> 'Option.t
                          val find_exn : 'a t -> id -> 'a
                          val remove : 'a t -> id -> 'a t
                          val mem : 'a t -> id -> bool
                          val iter_keys : 'a t -> f:(id -> unit) -> unit
                          val iter : 'a t -> f:('-> unit) -> unit
                          val iteri :
                            'a t -> f:(key:id -> data:'-> unit) -> unit
                          val iter2 :
                            'a t ->
                            'b t ->
                            f:(key:id ->
                               data:[ `Both of 'a * 'b
                                    | `Left of 'a
                                    | `Right of 'b ] ->
                               unit) ->
                            unit
                          val map : 'a t -> f:('-> 'b) -> 'b t
                          val mapi :
                            'a t -> f:(key:id -> data:'-> 'b) -> 'b t
                          val fold :
                            'a t ->
                            init:'->
                            f:(key:id -> data:'-> '-> 'b) -> 'b
                          val fold_right :
                            'a t ->
                            init:'->
                            f:(key:id -> data:'-> '-> 'b) -> 'b
                          val fold2 :
                            'a t ->
                            'b t ->
                            init:'->
                            f:(key:id ->
                               data:[ `Both of 'a * 'b
                                    | `Left of 'a
                                    | `Right of 'b ] ->
                               '-> 'c) ->
                            'c
                          val filter_keys : 'a t -> f:(id -> bool) -> 'a t
                          val filter : 'a t -> f:('-> bool) -> 'a t
                          val filteri :
                            'a t -> f:(key:id -> data:'-> bool) -> 'a t
                          val filter_map :
                            'a t -> f:('-> 'Option.t) -> 'b t
                          val filter_mapi :
                            'a t ->
                            f:(key:id -> data:'-> 'Option.t) -> 'b t
                          val partition_mapi :
                            'a t ->
                            f:(key:id ->
                               data:'-> [ `Fst of '| `Snd of 'c ]) ->
                            'b t * 'c t
                          val partition_map :
                            'a t ->
                            f:('-> [ `Fst of '| `Snd of 'c ]) ->
                            'b t * 'c t
                          val partitioni_tf :
                            'a t ->
                            f:(key:id -> data:'-> bool) -> 'a t * 'a t
                          val partition_tf :
                            'a t -> f:('-> bool) -> 'a t * 'a t
                          val compare_direct :
                            ('-> '-> int) -> 'a t -> 'a t -> int
                          val equal :
                            ('-> '-> bool) -> 'a t -> 'a t -> bool
                          val keys : 'a t -> id List.t
                          val data : 'a t -> 'List.t
                          val to_alist :
                            ?key_order:[ `Decreasing | `Increasing ] ->
                            'a t -> (id * 'a) List.t
                          val validate :
                            name:(id -> string) ->
                            'Base__.Validate.check ->
                            'a t Base__.Validate.check
                          val merge :
                            'a t ->
                            'b t ->
                            f:(key:id ->
                               [ `Both of 'a * 'b
                               | `Left of 'a
                               | `Right of 'b ] -> 'Option.t) ->
                            'c t
                          val symmetric_diff :
                            'a t ->
                            'a t ->
                            data_equal:('-> '-> bool) ->
                            (id, 'a)
                            Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                            Base__.Sequence.t
                          val min_elt : 'a t -> (id * 'a) Option.t
                          val min_elt_exn : 'a t -> id * 'a
                          val max_elt : 'a t -> (id * 'a) Option.t
                          val max_elt_exn : 'a t -> id * 'a
                          val for_all : 'a t -> f:('-> bool) -> bool
                          val for_alli :
                            'a t -> f:(key:id -> data:'-> bool) -> bool
                          val exists : 'a t -> f:('-> bool) -> bool
                          val existsi :
                            'a t -> f:(key:id -> data:'-> bool) -> bool
                          val count : 'a t -> f:('-> bool) -> int
                          val counti :
                            'a t -> f:(key:id -> data:'-> bool) -> int
                          val split :
                            'a t -> id -> 'a t * (id * 'a) Option.t * 'a t
                          val append :
                            lower_part:'a t ->
                            upper_part:'a t ->
                            [ `Ok of 'a t | `Overlapping_key_ranges ]
                          val subrange :
                            'a t ->
                            lower_bound:id Base__.Maybe_bound.t ->
                            upper_bound:id Base__.Maybe_bound.t -> 'a t
                          val fold_range_inclusive :
                            'a t ->
                            min:id ->
                            max:id ->
                            init:'->
                            f:(key:id -> data:'-> '-> 'b) -> 'b
                          val range_to_alist :
                            'a t -> min:id -> max:id -> (id * 'a) List.t
                          val closest_key :
                            'a t ->
                            [ `Greater_or_equal_to
                            | `Greater_than
                            | `Less_or_equal_to
                            | `Less_than ] -> id -> (id * 'a) Option.t
                          val nth : 'a t -> int -> (id * 'a) Option.t
                          val nth_exn : 'a t -> int -> id * 'a
                          val rank : 'a t -> id -> int Option.t
                          val to_tree : 'a t -> 'a t
                          val to_sequence :
                            ?order:[ `Decreasing_key | `Increasing_key ] ->
                            ?keys_greater_or_equal_to:id ->
                            ?keys_less_or_equal_to:id ->
                            'a t -> (id * 'a) Base__.Sequence.t
                          val obs :
                            id Core_kernel__.Quickcheck.Observer.t ->
                            'Core_kernel__.Quickcheck.Observer.t ->
                            'v t Core_kernel__.Quickcheck.Observer.t
                          val shrinker :
                            id Core_kernel__.Quickcheck.Shrinker.t ->
                            'Core_kernel__.Quickcheck.Shrinker.t ->
                            'v t Core_kernel__.Quickcheck.Shrinker.t
                          module Provide_of_sexp :
                            functor
                              (K : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> id
                                   end->
                              sig
                                val t_of_sexp :
                                  (Sexplib.Sexp.t -> 'v_x__017_) ->
                                  Sexplib.Sexp.t -> 'v_x__017_ t
                              end
                          val t_of_sexp :
                            (Base__.Sexplib.Sexp.t -> 'a) ->
                            Base__.Sexplib.Sexp.t -> 'a t
                          val sexp_of_t :
                            ('-> Base__.Sexplib.Sexp.t) ->
                            'a t -> Base__.Sexplib.Sexp.t
                        end
                      type 'a t =
                          (id, 'a, comparator_witness)
                          Core_kernel__.Core_map_intf.Map.t
                      val compare :
                        ('-> '-> Core_kernel__.Import.int) ->
                        'a t -> 'a t -> Core_kernel__.Import.int
                      val empty : 'a t
                      val singleton : id -> '-> 'a t
                      val of_alist :
                        (id * 'a) List.t ->
                        [ `Duplicate_key of id | `Ok of 'a t ]
                      val of_alist_or_error :
                        (id * 'a) List.t -> 'a t Base__.Or_error.t
                      val of_alist_exn : (id * 'a) List.t -> 'a t
                      val of_alist_multi : (id * 'a) List.t -> 'List.t t
                      val of_alist_fold :
                        (id * 'a) List.t ->
                        init:'-> f:('-> '-> 'b) -> 'b t
                      val of_alist_reduce :
                        (id * 'a) List.t -> f:('-> '-> 'a) -> 'a t
                      val of_sorted_array :
                        (id * 'a) array -> 'a t Base__.Or_error.t
                      val of_sorted_array_unchecked : (id * 'a) array -> 'a t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> id * 'a) -> 'a t
                      val of_iteri :
                        iteri:(f:(key:id -> data:'-> unit) -> unit) ->
                        [ `Duplicate_key of id | `Ok of 'v t ]
                      val of_tree : 'Tree.t -> 'a t
                      val of_hashtbl_exn :
                        (id, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                      val gen :
                        id Core_kernel__.Quickcheck.Generator.t ->
                        'Core_kernel__.Quickcheck.Generator.t ->
                        'a t Core_kernel__.Quickcheck.Generator.t
                      val invariants : 'a t -> bool
                      val is_empty : 'a t -> bool
                      val length : 'a t -> int
                      val add : 'a t -> key:id -> data:'-> 'a t
                      val add_multi :
                        'List.t t -> key:id -> data:'-> 'List.t t
                      val remove_multi : 'List.t t -> id -> 'List.t t
                      val change :
                        'a t -> id -> f:('Option.t -> 'Option.t) -> 'a t
                      val update :
                        'a t -> id -> f:('Option.t -> 'a) -> 'a t
                      val find : 'a t -> id -> 'Option.t
                      val find_exn : 'a t -> id -> 'a
                      val remove : 'a t -> id -> 'a t
                      val mem : 'a t -> id -> bool
                      val iter_keys : 'a t -> f:(id -> unit) -> unit
                      val iter : 'a t -> f:('-> unit) -> unit
                      val iteri :
                        'a t -> f:(key:id -> data:'-> unit) -> unit
                      val iter2 :
                        'a t ->
                        'b t ->
                        f:(key:id ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           unit) ->
                        unit
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val mapi : 'a t -> f:(key:id -> data:'-> 'b) -> 'b t
                      val fold :
                        'a t ->
                        init:'-> f:(key:id -> data:'-> '-> 'b) -> 'b
                      val fold_right :
                        'a t ->
                        init:'-> f:(key:id -> data:'-> '-> 'b) -> 'b
                      val fold2 :
                        'a t ->
                        'b t ->
                        init:'->
                        f:(key:id ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           '-> 'c) ->
                        'c
                      val filter_keys : 'a t -> f:(id -> bool) -> 'a t
                      val filter : 'a t -> f:('-> bool) -> 'a t
                      val filteri :
                        'a t -> f:(key:id -> data:'-> bool) -> 'a t
                      val filter_map : 'a t -> f:('-> 'Option.t) -> 'b t
                      val filter_mapi :
                        'a t -> f:(key:id -> data:'-> 'Option.t) -> 'b t
                      val partition_mapi :
                        'a t ->
                        f:(key:id -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                        'b t * 'c t
                      val partition_map :
                        'a t ->
                        f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                      val partitioni_tf :
                        'a t -> f:(key:id -> data:'-> bool) -> 'a t * 'a t
                      val partition_tf :
                        'a t -> f:('-> bool) -> 'a t * 'a t
                      val compare_direct :
                        ('-> '-> int) -> 'a t -> 'a t -> int
                      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                      val keys : 'a t -> id List.t
                      val data : 'a t -> 'List.t
                      val to_alist :
                        ?key_order:[ `Decreasing | `Increasing ] ->
                        'a t -> (id * 'a) List.t
                      val validate :
                        name:(id -> string) ->
                        'Base__.Validate.check ->
                        'a t Base__.Validate.check
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:id ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'Option.t) ->
                        'c t
                      val symmetric_diff :
                        'a t ->
                        'a t ->
                        data_equal:('-> '-> bool) ->
                        (id, 'a)
                        Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                        Base__.Sequence.t
                      val min_elt : 'a t -> (id * 'a) Option.t
                      val min_elt_exn : 'a t -> id * 'a
                      val max_elt : 'a t -> (id * 'a) Option.t
                      val max_elt_exn : 'a t -> id * 'a
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val for_alli :
                        'a t -> f:(key:id -> data:'-> bool) -> bool
                      val exists : 'a t -> f:('-> bool) -> bool
                      val existsi :
                        'a t -> f:(key:id -> data:'-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val counti :
                        'a t -> f:(key:id -> data:'-> bool) -> int
                      val split :
                        'a t -> id -> 'a t * (id * 'a) Option.t * 'a t
                      val append :
                        lower_part:'a t ->
                        upper_part:'a t ->
                        [ `Ok of 'a t | `Overlapping_key_ranges ]
                      val subrange :
                        'a t ->
                        lower_bound:id Base__.Maybe_bound.t ->
                        upper_bound:id Base__.Maybe_bound.t -> 'a t
                      val fold_range_inclusive :
                        'a t ->
                        min:id ->
                        max:id ->
                        init:'-> f:(key:id -> data:'-> '-> 'b) -> 'b
                      val range_to_alist :
                        'a t -> min:id -> max:id -> (id * 'a) List.t
                      val closest_key :
                        'a t ->
                        [ `Greater_or_equal_to
                        | `Greater_than
                        | `Less_or_equal_to
                        | `Less_than ] -> id -> (id * 'a) Option.t
                      val nth : 'a t -> int -> (id * 'a) Option.t
                      val nth_exn : 'a t -> int -> id * 'a
                      val rank : 'a t -> id -> int Option.t
                      val to_tree : 'a t -> 'Tree.t
                      val to_sequence :
                        ?order:[ `Decreasing_key | `Increasing_key ] ->
                        ?keys_greater_or_equal_to:id ->
                        ?keys_less_or_equal_to:id ->
                        'a t -> (id * 'a) Base__.Sequence.t
                      val obs :
                        id Core_kernel__.Quickcheck.Observer.t ->
                        'Core_kernel__.Quickcheck.Observer.t ->
                        'v t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        id Core_kernel__.Quickcheck.Shrinker.t ->
                        'Core_kernel__.Quickcheck.Shrinker.t ->
                        'v t Core_kernel__.Quickcheck.Shrinker.t
                      module Provide_of_sexp :
                        functor
                          (Key : sig val t_of_sexp : Sexplib.Sexp.t -> id end->
                          sig
                            val t_of_sexp :
                              (Sexplib.Sexp.t -> 'v_x__018_) ->
                              Sexplib.Sexp.t -> 'v_x__018_ t
                          end
                      module Provide_bin_io :
                        functor
                          (Key : sig
                                   val bin_t : id Bin_prot.Type_class.t
                                   val bin_read_t : id Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> id)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     id Bin_prot.Type_class.reader
                                   val bin_size_t : id Bin_prot.Size.sizer
                                   val bin_write_t : id Bin_prot.Write.writer
                                   val bin_writer_t :
                                     id Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                          sig
                            val bin_shape_t :
                              Bin_prot.Shape.t -> Bin_prot.Shape.t
                            val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                            val bin_write_t :
                              ('a, 'a t) Bin_prot.Write.writer1
                            val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                            val __bin_read_t__ :
                              ('a, int -> 'a t) Bin_prot.Read.reader1
                            val bin_writer_t :
                              ('a, 'a t) Bin_prot.Type_class.S1.writer
                            val bin_reader_t :
                              ('a, 'a t) Bin_prot.Type_class.S1.reader
                            val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                          end
                      module Provide_hash :
                        functor
                          (Key : sig
                                   val hash_fold_t :
                                     Base__.Hash.state ->
                                     id -> Base__.Hash.state
                                 end->
                          sig
                            val hash_fold_t :
                              (Ppx_hash_lib.Std.Hash.state ->
                               '-> Ppx_hash_lib.Std.Hash.state) ->
                              Ppx_hash_lib.Std.Hash.state ->
                              'a t -> Ppx_hash_lib.Std.Hash.state
                          end
                      val t_of_sexp :
                        (Base__.Sexplib.Sexp.t -> 'a) ->
                        Base__.Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Base__.Sexplib.Sexp.t) ->
                        'a t -> Base__.Sexplib.Sexp.t
                      val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                      val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                      val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                      val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                      val __bin_read_t__ :
                        ('a, int -> 'a t) Bin_prot.Read.reader1
                      val bin_writer_t :
                        ('a, 'a t) Bin_prot.Type_class.S1.writer
                      val bin_reader_t :
                        ('a, 'a t) Bin_prot.Type_class.S1.reader
                      val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                    end
                  module Set :
                    sig
                      module Elt :
                        sig
                          type t = id
                          val bin_t : t Bin_prot.Type_class.t
                          val bin_read_t : t Bin_prot.Read.reader
                          val __bin_read_t__ :
                            (Core_kernel__.Import.int -> t)
                            Bin_prot.Read.reader
                          val bin_reader_t : t Bin_prot.Type_class.reader
                          val bin_size_t : t Bin_prot.Size.sizer
                          val bin_write_t : t Bin_prot.Write.writer
                          val bin_writer_t : t Bin_prot.Type_class.writer
                          val bin_shape_t : Bin_prot.Shape.t
                          val t_of_sexp : Sexplib.Sexp.t -> t
                          val sexp_of_t : t -> Sexplib.Sexp.t
                          type comparator_witness =
                              Map.Key.comparator_witness
                          val comparator :
                            (t, comparator_witness)
                            Core_kernel__.Comparator.comparator
                        end
                      module Tree :
                        sig
                          type t =
                              (id, comparator_witness)
                              Core_kernel__.Core_set_intf.Tree.t
                          val compare : t -> t -> Core_kernel__.Import.int
                          val length : t -> int
                          val is_empty : t -> bool
                          val iter : t -> f:(id -> unit) -> unit
                          val fold :
                            t ->
                            init:'accum ->
                            f:('accum -> id -> 'accum) -> 'accum
                          val fold_result :
                            t ->
                            init:'accum ->
                            f:('accum -> id -> ('accum, 'e) Base__.Result.t) ->
                            ('accum, 'e) Base__.Result.t
                          val exists : t -> f:(id -> bool) -> bool
                          val for_all : t -> f:(id -> bool) -> bool
                          val count : t -> f:(id -> bool) -> int
                          val sum :
                            (module Base__.Commutative_group.S with type t = 'sum) ->
                            t -> f:(id -> 'sum) -> 'sum
                          val find : t -> f:(id -> bool) -> id Option.t
                          val find_map :
                            t -> f:(id -> 'Option.t) -> 'Option.t
                          val to_list : t -> id List.t
                          val to_array : t -> id array
                          val invariants : t -> bool
                          val mem : t -> id -> bool
                          val add : t -> id -> t
                          val remove : t -> id -> t
                          val union : t -> t -> t
                          val inter : t -> t -> t
                          val diff : t -> t -> t
                          val symmetric_diff :
                            t ->
                            t -> (id, id) Base__.Either.t Base__.Sequence.t
                          val compare_direct : t -> t -> int
                          val equal : t -> t -> bool
                          val is_subset : t -> of_:t -> bool
                          val subset : t -> t -> bool
                          val fold_until :
                            t ->
                            init:'->
                            f:('->
                               id ->
                               ('b, 'stop)
                               Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                            ('b, 'stop)
                            Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                          val fold_right :
                            t -> init:'-> f:(id -> '-> 'b) -> 'b
                          val iter2 :
                            t ->
                            t ->
                            f:([ `Both of id * id
                               | `Left of id
                               | `Right of id ] -> unit) ->
                            unit
                          val filter : t -> f:(id -> bool) -> t
                          val partition_tf : t -> f:(id -> bool) -> t * t
                          val elements : t -> id List.t
                          val min_elt : t -> id Option.t
                          val min_elt_exn : t -> id
                          val max_elt : t -> id Option.t
                          val max_elt_exn : t -> id
                          val choose : t -> id Option.t
                          val choose_exn : t -> id
                          val split : t -> id -> t * id Option.t * t
                          val group_by :
                            t -> equiv:(id -> id -> bool) -> t List.t
                          val find_exn : t -> f:(id -> bool) -> id
                          val find_index : t -> int -> id Option.t
                          val nth : t -> int -> id Option.t
                          val remove_index : t -> int -> t
                          val to_tree : t -> t
                          val to_sequence :
                            ?order:[ `Decreasing | `Increasing ] ->
                            ?greater_or_equal_to:id ->
                            ?less_or_equal_to:id -> t -> id Base__.Sequence.t
                          val merge_to_sequence :
                            ?order:[ `Decreasing | `Increasing ] ->
                            ?greater_or_equal_to:id ->
                            ?less_or_equal_to:id ->
                            t ->
                            t ->
                            (id, id)
                            Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                            Base__.Sequence.t
                          val to_map :
                            t ->
                            f:(id -> 'data) ->
                            (id, 'data, comparator_witness)
                            Core_kernel__.Core_set_intf.Map.t
                          val obs :
                            id Core_kernel__.Quickcheck.Observer.t ->
                            t Core_kernel__.Quickcheck.Observer.t
                          val shrinker :
                            id Core_kernel__.Quickcheck.Shrinker.t ->
                            t Core_kernel__.Quickcheck.Shrinker.t
                          val empty : t
                          val singleton : id -> t
                          val union_list : t List.t -> t
                          val of_list : id List.t -> t
                          val of_array : id array -> t
                          val of_sorted_array :
                            id array -> t Base__.Or_error.t
                          val of_sorted_array_unchecked : id array -> t
                          val of_increasing_iterator_unchecked :
                            len:int -> f:(int -> id) -> t
                          val stable_dedup_list : id List.t -> id List.t
                          val map :
                            ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                            f:('-> id) -> t
                          val filter_map :
                            ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                            f:('-> id Option.t) -> t
                          val of_tree : t -> t
                          val of_hash_set : id Core_kernel__.Hash_set.t -> t
                          val of_hashtbl_keys :
                            (id, 'a) Core_kernel__.Core_hashtbl.t -> t
                          val of_map_keys :
                            (id, 'a, comparator_witness)
                            Core_kernel__.Core_set_intf.Map.t -> t
                          val gen :
                            id Core_kernel__.Quickcheck.Generator.t ->
                            t Core_kernel__.Quickcheck.Generator.t
                          module Provide_of_sexp :
                            functor
                              (Elt : sig
                                       val t_of_sexp : Sexplib.Sexp.t -> id
                                     end->
                              sig val t_of_sexp : Sexplib.Sexp.t -> t end
                          val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                          val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                        end
                      type t = (id, comparator_witness) Base.Set.t
                      val compare : t -> t -> Core_kernel__.Import.int
                      val length : t -> int
                      val is_empty : t -> bool
                      val iter : t -> f:(id -> unit) -> unit
                      val fold :
                        t ->
                        init:'accum -> f:('accum -> id -> 'accum) -> 'accum
                      val fold_result :
                        t ->
                        init:'accum ->
                        f:('accum -> id -> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val exists : t -> f:(id -> bool) -> bool
                      val for_all : t -> f:(id -> bool) -> bool
                      val count : t -> f:(id -> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        t -> f:(id -> 'sum) -> 'sum
                      val find : t -> f:(id -> bool) -> id Option.t
                      val find_map :
                        t -> f:(id -> 'Option.t) -> 'Option.t
                      val to_list : t -> id List.t
                      val to_array : t -> id array
                      val invariants : t -> bool
                      val mem : t -> id -> bool
                      val add : t -> id -> t
                      val remove : t -> id -> t
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val symmetric_diff :
                        t -> t -> (id, id) Base__.Either.t Base__.Sequence.t
                      val compare_direct : t -> t -> int
                      val equal : t -> t -> bool
                      val is_subset : t -> of_:t -> bool
                      val subset : t -> t -> bool
                      val fold_until :
                        t ->
                        init:'->
                        f:('->
                           id ->
                           ('b, 'stop)
                           Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                        ('b, 'stop)
                        Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                      val fold_right :
                        t -> init:'-> f:(id -> '-> 'b) -> 'b
                      val iter2 :
                        t ->
                        t ->
                        f:([ `Both of id * id | `Left of id | `Right of id ] ->
                           unit) ->
                        unit
                      val filter : t -> f:(id -> bool) -> t
                      val partition_tf : t -> f:(id -> bool) -> t * t
                      val elements : t -> id List.t
                      val min_elt : t -> id Option.t
                      val min_elt_exn : t -> id
                      val max_elt : t -> id Option.t
                      val max_elt_exn : t -> id
                      val choose : t -> id Option.t
                      val choose_exn : t -> id
                      val split : t -> id -> t * id Option.t * t
                      val group_by :
                        t -> equiv:(id -> id -> bool) -> t List.t
                      val find_exn : t -> f:(id -> bool) -> id
                      val find_index : t -> int -> id Option.t
                      val nth : t -> int -> id Option.t
                      val remove_index : t -> int -> t
                      val to_tree : t -> Tree.t
                      val to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:id ->
                        ?less_or_equal_to:id -> t -> id Base__.Sequence.t
                      val merge_to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:id ->
                        ?less_or_equal_to:id ->
                        t ->
                        t ->
                        (id, id)
                        Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                        Base__.Sequence.t
                      val to_map :
                        t ->
                        f:(id -> 'data) ->
                        (id, 'data, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t
                      val obs :
                        id Core_kernel__.Quickcheck.Observer.t ->
                        t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        id Core_kernel__.Quickcheck.Shrinker.t ->
                        t Core_kernel__.Quickcheck.Shrinker.t
                      val empty : t
                      val singleton : id -> t
                      val union_list : t List.t -> t
                      val of_list : id List.t -> t
                      val of_array : id array -> t
                      val of_sorted_array : id array -> t Base__.Or_error.t
                      val of_sorted_array_unchecked : id array -> t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> id) -> t
                      val stable_dedup_list : id List.t -> id List.t
                      val map : ('a, 'b) Base.Set.t -> f:('-> id) -> t
                      val filter_map :
                        ('a, 'b) Base.Set.t -> f:('-> id Option.t) -> t
                      val of_tree : Tree.t -> t
                      val of_hash_set : id Core_kernel__.Hash_set.t -> t
                      val of_hashtbl_keys :
                        (id, 'a) Core_kernel__.Core_hashtbl.t -> t
                      val of_map_keys :
                        (id, 'a, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t -> t
                      val gen :
                        id Core_kernel__.Quickcheck.Generator.t ->
                        t Core_kernel__.Quickcheck.Generator.t
                      module Provide_of_sexp :
                        functor
                          (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> id end->
                          sig val t_of_sexp : Sexplib.Sexp.t -> t end
                      module Provide_bin_io :
                        functor
                          (Elt : sig
                                   val bin_t : id Bin_prot.Type_class.t
                                   val bin_read_t : id Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> id)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     id Bin_prot.Type_class.reader
                                   val bin_size_t : id Bin_prot.Size.sizer
                                   val bin_write_t : id Bin_prot.Write.writer
                                   val bin_writer_t :
                                     id Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                          sig
                            val bin_size_t : t Bin_prot.Size.sizer
                            val bin_write_t : t Bin_prot.Write.writer
                            val bin_read_t : t Bin_prot.Read.reader
                            val __bin_read_t__ :
                              (int -> t) Bin_prot.Read.reader
                            val bin_shape_t : Bin_prot.Shape.t
                            val bin_writer_t : t Bin_prot.Type_class.writer
                            val bin_reader_t : t Bin_prot.Type_class.reader
                            val bin_t : t Bin_prot.Type_class.t
                          end
                      module Provide_hash :
                        functor
                          (Elt : sig
                                   val hash_fold_t :
                                     Base__.Hash.state ->
                                     id -> Base__.Hash.state
                                 end->
                          sig
                            val hash_fold_t :
                              Ppx_hash_lib.Std.Hash.state ->
                              t -> Ppx_hash_lib.Std.Hash.state
                            val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                          end
                      val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                      val bin_shape_t : Bin_prot.Shape.t
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_t : t Bin_prot.Type_class.t
                    end
                  val hash : t -> Core_kernel__.Import.int
                  val hashable : t Core_kernel__.Hashable.Hashtbl.Hashable.t
                  module Table :
                    sig
                      type key = t
                      type ('a, 'b) hashtbl = ('a, 'b) Id.Table.hashtbl
                      type 'b t = (key, 'b) hashtbl
                      val sexp_of_t :
                        ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                      type ('a, 'b) t_ = 'b t
                      type 'a key_ = key
                      val hashable :
                        key Core_kernel__.Core_hashtbl_intf.Hashable.t
                      val invariant :
                        'Base__.Invariant_intf.inv ->
                        'a t Base__.Invariant_intf.inv
                      val create :
                        (key, 'b, unit -> 'b t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist :
                        (key, 'b,
                         (key * 'b) List.t ->
                         [ `Duplicate_key of key | `Ok of 'b t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_report_all_dups :
                        (key, 'b,
                         (key * 'b) List.t ->
                         [ `Duplicate_keys of key List.t | `Ok of 'b t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_or_error :
                        (key, 'b,
                         (key * 'b) List.t -> 'b t Base__.Or_error.t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_exn :
                        (key, 'b, (key * 'b) List.t -> 'b t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_multi :
                        (key, 'List.t, (key * 'b) List.t -> 'List.t t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_mapped :
                        (key, 'b,
                         get_key:('-> key) ->
                         get_data:('-> 'b) ->
                         'List.t ->
                         [ `Duplicate_keys of key List.t | `Ok of 'b t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_with_key :
                        (key, 'r,
                         get_key:('-> key) ->
                         'List.t ->
                         [ `Duplicate_keys of key List.t | `Ok of 'r t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_with_key_or_error :
                        (key, 'r,
                         get_key:('-> key) ->
                         'List.t -> 'r t Base__.Or_error.t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_with_key_exn :
                        (key, 'r, get_key:('-> key) -> 'List.t -> 'r t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val group :
                        (key, 'b,
                         get_key:('-> key) ->
                         get_data:('-> 'b) ->
                         combine:('-> '-> 'b) -> 'List.t -> 'b t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                      val clear : 'a t -> unit
                      val copy : 'b t -> 'b t
                      val fold :
                        'b t ->
                        init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                      val iter_keys : 'a t -> f:(key -> unit) -> unit
                      val iter : 'b t -> f:('-> unit) -> unit
                      val iteri :
                        'b t -> f:(key:key -> data:'-> unit) -> unit
                      val iter_vals : 'b t -> f:('-> unit) -> unit
                      val existsi :
                        'b t -> f:(key:key -> data:'-> bool) -> bool
                      val exists : 'b t -> f:('-> bool) -> bool
                      val for_alli :
                        'b t -> f:(key:key -> data:'-> bool) -> bool
                      val for_all : 'b t -> f:('-> bool) -> bool
                      val counti :
                        'b t -> f:(key:key -> data:'-> bool) -> int
                      val count : 'b t -> f:('-> bool) -> int
                      val length : 'a t -> int
                      val is_empty : 'a t -> bool
                      val mem : 'a t -> key -> bool
                      val remove : 'a t -> key -> unit
                      val replace : 'b t -> key:key -> data:'-> unit
                      val set : 'b t -> key:key -> data:'-> unit
                      val add :
                        'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                      val add_or_error :
                        'b t -> key:key -> data:'-> unit Base__.Or_error.t
                      val add_exn : 'b t -> key:key -> data:'-> unit
                      val change :
                        'b t -> key -> f:('Option.t -> 'Option.t) -> unit
                      val update :
                        'b t -> key -> f:('Option.t -> 'b) -> unit
                      val add_multi :
                        'List.t t -> key:key -> data:'-> unit
                      val remove_multi : 'List.t t -> key -> unit
                      val map : 'b t -> f:('-> 'c) -> 'c t
                      val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                      val filter_map : 'b t -> f:('-> 'Option.t) -> 'c t
                      val filter_mapi :
                        'b t -> f:(key:key -> data:'-> 'Option.t) -> 'c t
                      val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                      val filter : 'b t -> f:('-> bool) -> 'b t
                      val filteri :
                        'b t -> f:(key:key -> data:'-> bool) -> 'b t
                      val partition_map :
                        'b t ->
                        f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
                      val partition_mapi :
                        'b t ->
                        f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                        'c t * 'd t
                      val partition_tf :
                        'b t -> f:('-> bool) -> 'b t * 'b t
                      val partitioni_tf :
                        'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
                      val find_or_add :
                        'b t -> key -> default:(unit -> 'b) -> 'b
                      val find : 'b t -> key -> 'Option.t
                      val find_exn : 'b t -> key -> 'b
                      val find_and_call :
                        'b t ->
                        key ->
                        if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
                      val find_and_remove : 'b t -> key -> 'Option.t
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:key ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'Option.t) ->
                        'c t
                      type 'a merge_into_action = Remove | Set_to of 'a
                      val merge_into :
                        src:'a t ->
                        dst:'b t ->
                        f:(key:key ->
                           '-> 'Option.t -> 'b merge_into_action) ->
                        unit
                      val keys : 'a t -> key List.t
                      val data : 'b t -> 'List.t
                      val filter_keys_inplace :
                        'a t -> f:(key -> bool) -> unit
                      val filter_inplace : 'b t -> f:('-> bool) -> unit
                      val filteri_inplace :
                        'b t -> f:(key:key -> data:'-> bool) -> unit
                      val map_inplace : 'b t -> f:('-> 'b) -> unit
                      val mapi_inplace :
                        'b t -> f:(key:key -> data:'-> 'b) -> unit
                      val filter_map_inplace :
                        'b t -> f:('-> 'Option.t) -> unit
                      val filter_mapi_inplace :
                        'b t -> f:(key:key -> data:'-> 'Option.t) -> unit
                      val replace_all : 'b t -> f:('-> 'b) -> unit
                      val replace_alli :
                        'b t -> f:(key:key -> data:'-> 'b) -> unit
                      val filter_replace_all :
                        'b t -> f:('-> 'Option.t) -> unit
                      val filter_replace_alli :
                        'b t -> f:(key:key -> data:'-> 'Option.t) -> unit
                      val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
                      val similar :
                        'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                      val to_alist : 'b t -> (key * 'b) List.t
                      val validate :
                        name:(key -> string) ->
                        'Base__.Validate.check ->
                        'b t Base__.Validate.check
                      val incr :
                        ?by:int ->
                        ?remove_if_zero:bool -> int t -> key -> unit
                      val decr :
                        ?by:int ->
                        ?remove_if_zero:bool -> int t -> key -> unit
                      module Provide_of_sexp :
                        functor
                          (Key : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> key
                                 end->
                          sig
                            val t_of_sexp :
                              (Sexplib.Sexp.t -> 'v_x__001_) ->
                              Sexplib.Sexp.t -> 'v_x__001_ t
                          end
                      module Provide_bin_io :
                        functor
                          (Key : sig
                                   val bin_t : key Bin_prot.Type_class.t
                                   val bin_read_t : key Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> key)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     key Bin_prot.Type_class.reader
                                   val bin_size_t : key Bin_prot.Size.sizer
                                   val bin_write_t :
                                     key Bin_prot.Write.writer
                                   val bin_writer_t :
                                     key Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                          sig
                            val bin_t :
                              'Bin_prot.Type_class.t ->
                              'a t Bin_prot.Type_class.t
                            val bin_read_t :
                              'Bin_prot.Read.reader ->
                              'a t Bin_prot.Read.reader
                            val __bin_read_t__ :
                              'Bin_prot.Read.reader ->
                              (Core_kernel__.Import.int -> 'a t)
                              Bin_prot.Read.reader
                            val bin_reader_t :
                              'Bin_prot.Type_class.reader ->
                              'a t Bin_prot.Type_class.reader
                            val bin_size_t :
                              'Bin_prot.Size.sizer ->
                              'a t Bin_prot.Size.sizer
                            val bin_write_t :
                              'Bin_prot.Write.writer ->
                              'a t Bin_prot.Write.writer
                            val bin_writer_t :
                              'Bin_prot.Type_class.writer ->
                              'a t Bin_prot.Type_class.writer
                            val bin_shape_t :
                              Bin_prot.Shape.t -> Bin_prot.Shape.t
                          end
                      val t_of_sexp :
                        (Sexplib.Sexp.t -> 'v_x__002_) ->
                        Sexplib.Sexp.t -> 'v_x__002_ t
                      val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                      val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                      val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                      val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                      val __bin_read_t__ :
                        ('a, int -> 'a t) Bin_prot.Read.reader1
                      val bin_writer_t :
                        ('a, 'a t) Bin_prot.Type_class.S1.writer
                      val bin_reader_t :
                        ('a, 'a t) Bin_prot.Type_class.S1.reader
                      val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                    end
                  module Hash_set :
                    sig
                      type elt = t
                      type t = elt Core_kernel__.Hash_set.t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      type 'a t_ = t
                      type 'a elt_ = elt
                      val create :
                        ('a, unit -> t)
                        Core_kernel__.Hash_set_intf.create_options_without_hashable
                      val of_list :
                        ('a, elt List.t -> t)
                        Core_kernel__.Hash_set_intf.create_options_without_hashable
                      module Provide_of_sexp :
                        functor
                          (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                          sig val t_of_sexp : Sexplib.Sexp.t -> t end
                      module Provide_bin_io :
                        functor
                          (X : sig
                                 val bin_t : elt Bin_prot.Type_class.t
                                 val bin_read_t : elt Bin_prot.Read.reader
                                 val __bin_read_t__ :
                                   (Core_kernel__.Import.int -> elt)
                                   Bin_prot.Read.reader
                                 val bin_reader_t :
                                   elt Bin_prot.Type_class.reader
                                 val bin_size_t : elt Bin_prot.Size.sizer
                                 val bin_write_t : elt Bin_prot.Write.writer
                                 val bin_writer_t :
                                   elt Bin_prot.Type_class.writer
                                 val bin_shape_t : Bin_prot.Shape.t
                               end->
                          sig
                            val bin_t : t Bin_prot.Type_class.t
                            val bin_read_t : t Bin_prot.Read.reader
                            val __bin_read_t__ :
                              (Core_kernel__.Import.int -> t)
                              Bin_prot.Read.reader
                            val bin_reader_t : t Bin_prot.Type_class.reader
                            val bin_size_t : t Bin_prot.Size.sizer
                            val bin_write_t : t Bin_prot.Write.writer
                            val bin_writer_t : t Bin_prot.Type_class.writer
                            val bin_shape_t : Bin_prot.Shape.t
                          end
                      val t_of_sexp : Sexplib.Sexp.t -> t
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                      val bin_shape_t : Bin_prot.Shape.t
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_t : t Bin_prot.Type_class.t
                    end
                  module Hash_queue :
                    sig
                      module Key :
                        sig
                          type t = id
                          val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                          val compare : t -> t -> int
                          val hash : t -> int
                        end
                      type 'a t
                      val sexp_of_t :
                        ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                      val length : 'a t -> int
                      val is_empty : 'a t -> bool
                      val iter : 'a t -> f:('-> unit) -> unit
                      val fold :
                        'a t ->
                        init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                      val fold_result :
                        'a t ->
                        init:'accum ->
                        f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val fold_until :
                        'a t ->
                        init:'accum ->
                        f:('accum ->
                           '->
                           ('accum, 'stop)
                           Base.Container_intf.Continue_or_stop.t) ->
                        ('accum, 'stop)
                        Base.Container_intf.Finished_or_stopped_early.t
                      val exists : 'a t -> f:('-> bool) -> bool
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        'a t -> f:('-> 'sum) -> 'sum
                      val find : 'a t -> f:('-> bool) -> 'Option.t
                      val find_map :
                        'a t -> f:('-> 'Option.t) -> 'Option.t
                      val to_list : 'a t -> 'List.t
                      val to_array : 'a t -> 'a array
                      val min_elt :
                        'a t -> cmp:('-> '-> int) -> 'Option.t
                      val max_elt :
                        'a t -> cmp:('-> '-> int) -> 'Option.t
                      val invariant : 'a t -> Core_kernel__.Import.unit
                      val create :
                        ?growth_allowed:Core_kernel__.Import.bool ->
                        ?size:Core_kernel__.Import.int ->
                        Core_kernel__.Import.unit -> 'a t
                      val clear : 'a t -> Core_kernel__.Import.unit
                      val mem : 'a t -> id -> Core_kernel__.Import.bool
                      val lookup :
                        'a t -> id -> 'Core_kernel__.Import.option
                      val lookup_exn : 'a t -> id -> 'a
                      val enqueue :
                        'a t -> id -> '-> [ `Key_already_present | `Ok ]
                      val enqueue_exn :
                        'a t -> id -> '-> Core_kernel__.Import.unit
                      val lookup_and_move_to_back :
                        'a t -> id -> 'Core_kernel__.Import.option
                      val lookup_and_move_to_back_exn : 'a t -> id -> 'a
                      val first : 'a t -> 'Core_kernel__.Import.option
                      val first_with_key :
                        'a t -> (id * 'a) Core_kernel__.Import.option
                      val keys : 'a t -> id Core_kernel__.Import.list
                      val dequeue : 'a t -> 'Core_kernel__.Import.option
                      val dequeue_exn : 'a t -> 'a
                      val dequeue_with_key :
                        'a t -> (id * 'a) Core_kernel__.Import.option
                      val dequeue_with_key_exn : 'a t -> id * 'a
                      val dequeue_all :
                        'a t ->
                        f:('-> Core_kernel__.Import.unit) ->
                        Core_kernel__.Import.unit
                      val remove : 'a t -> id -> [ `No_such_key | `Ok ]
                      val remove_exn :
                        'a t -> id -> Core_kernel__.Import.unit
                      val replace :
                        'a t -> id -> '-> [ `No_such_key | `Ok ]
                      val replace_exn :
                        'a t -> id -> '-> Core_kernel__.Import.unit
                      val iteri :
                        'a t ->
                        f:(key:id -> data:'-> Core_kernel__.Import.unit) ->
                        Core_kernel__.Import.unit
                      val foldi :
                        'a t ->
                        init:'-> f:('-> key:id -> data:'-> 'b) -> 'b
                    end
                  val pp : Base__.Import.Caml.Format.formatter -> t -> unit
                end
              val global : Monads.Std.Monad.State.Multi.S2.id
              val fork : unit -> (unit, 'e) t
              val switch : Monads.Std.Monad.State.Multi.S2.id -> (unit, 'e) t
              val parent : unit -> (Monads.Std.Monad.State.Multi.S2.id, 'e) t
              val ancestor :
                Monads.Std.Monad.State.Multi.S2.id list ->
                (Monads.Std.Monad.State.Multi.S2.id, 'e) t
              val current :
                unit -> (Monads.Std.Monad.State.Multi.S2.id, 'e) t
              val kill : Monads.Std.Monad.State.Multi.S2.id -> (unit, 'e) t
              val forks :
                unit ->
                (Monads.Std.Monad.State.Multi.S2.id
                 Core_kernel.Std.Sequence.t, 'e)
                t
              val status :
                Monads.Std.Monad.State.Multi.S2.id ->
                (Monads.Std.Monad.State.Multi.status, 'e) t
              val lift : 'a m -> ('a, 'e) t
              val run : ('a, 'e) t -> ('a, 'e) e
              val void : ('a, 'e) t -> (unit, 'e) t
              val sequence : (unit, 'e) t List.t -> (unit, 'e) t
              val forever : ('a, 'e) t -> ('b, 'e) t
              module Fn :
                sig
                  val id : '-> ('a, 'e) t
                  val ignore : ('a, 'e) t -> (unit, 'e) t
                  val nothing : unit -> (unit, 'e) t
                  val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
                  val apply_n_times :
                    n:int -> ('-> ('a, 'e) t) -> '-> ('a, 'e) t
                  val compose :
                    ('-> ('c, 'e) t) ->
                    ('-> ('b, 'e) t) -> '-> ('c, 'e) t
                end
              module Pair :
                sig
                  val fst : ('a * 'b, 'e) t -> ('a, 'e) t
                  val snd : ('a * 'b, 'e) t -> ('b, 'e) t
                end
              module Triple :
                sig
                  val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
                  val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
                  val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
                end
              module Lift :
                sig
                  val nullary : '-> ('a, 'e) t
                  val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                  val binary :
                    ('-> '-> 'c) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                  val ternary :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                  val quaternary :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) t ->
                    ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                  val quinary :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) t ->
                    ('b, 's) t ->
                    ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                end
              module Exn :
                sig
                  val expect :
                    ?finally:(unit -> (unit, 's) t) ->
                    f:(unit -> ('a, 's) t) ->
                    catch:(exn -> ('a, 's) t) -> ('a, 's) t
                end
              module Collection :
                sig
                  module type S =
                    sig
                      type 'a t
                      val all : ('a, 'e) t t -> ('a t, 'e) t
                      val all_ignore : ('a, 'e) t t -> (unit, 'e) t
                      val sequence : (unit, 'e) t t -> (unit, 'e) t
                      val map : 'a t -> f:('-> ('b, 'e) t) -> ('b t, 'e) t
                      val iter :
                        'a t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                      val fold :
                        'a t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_left :
                        'a t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_right :
                        'a t ->
                        f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                      val reduce :
                        'a t ->
                        f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                      val exists :
                        'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val for_all :
                        'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val count :
                        'a t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                      val find :
                        'a t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                      val find_map :
                        'a t ->
                        f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                      val filter :
                        'a t -> f:('-> (bool, 'e) t) -> ('a t, 'e) t
                      val filter_map :
                        'a t -> f:('-> ('Option.t, 'e) t) -> ('b t, 'e) t
                    end
                  module Eager :
                    functor (T : Collection.Eager->
                      sig
                        val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                        val all_ignore : ('a, 'e) t T.t -> (unit, 'e) t
                        val sequence : (unit, 'e) t T.t -> (unit, 'e) t
                        val map :
                          'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                        val iter :
                          'T.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                        val fold :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_left :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_right :
                          'T.t ->
                          f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                        val reduce :
                          'T.t ->
                          f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                        val exists :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val for_all :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val count :
                          'T.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                        val find :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                        val find_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) ->
                          ('Option.t, 'e) t
                        val filter :
                          'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                        val filter_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                      end
                  module Delay :
                    functor (T : Collection.Delay->
                      sig
                        val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                        val all_ignore : ('a, 'e) t T.t -> (unit, 'e) t
                        val sequence : (unit, 'e) t T.t -> (unit, 'e) t
                        val map :
                          'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                        val iter :
                          'T.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                        val fold :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_left :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_right :
                          'T.t ->
                          f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                        val reduce :
                          'T.t ->
                          f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                        val exists :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val for_all :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val count :
                          'T.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                        val find :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                        val find_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) ->
                          ('Option.t, 'e) t
                        val filter :
                          'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                        val filter_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                      end
                end
              module List :
                sig
                  val all : ('a, 'e) t List.t -> ('List.t, 'e) t
                  val all_ignore : ('a, 'e) t List.t -> (unit, 'e) t
                  val sequence : (unit, 'e) t List.t -> (unit, 'e) t
                  val map :
                    'List.t -> f:('-> ('b, 'e) t) -> ('List.t, 'e) t
                  val iter :
                    'List.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                  val fold :
                    'List.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'List.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'List.t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'List.t ->
                    f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                  val exists :
                    'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count :
                    'List.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'List.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'List.t ->
                    f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                  val find_map :
                    'List.t ->
                    f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                  val filter :
                    'List.t -> f:('-> (bool, 'e) t) -> ('List.t, 'e) t
                  val filter_map :
                    'List.t ->
                    f:('-> ('Option.t, 'e) t) -> ('List.t, 'e) t
                end
              module Seq :
                sig
                  val all : ('a, 'e) t Seq.t -> ('Seq.t, 'e) t
                  val all_ignore : ('a, 'e) t Seq.t -> (unit, 'e) t
                  val sequence : (unit, 'e) t Seq.t -> (unit, 'e) t
                  val map :
                    'Seq.t -> f:('-> ('b, 'e) t) -> ('Seq.t, 'e) t
                  val iter :
                    'Seq.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                  val fold :
                    'Seq.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'Seq.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'Seq.t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'Seq.t ->
                    f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                  val exists :
                    'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count :
                    'Seq.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'Seq.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'Seq.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                  val find_map :
                    'Seq.t ->
                    f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                  val filter :
                    'Seq.t -> f:('-> (bool, 'e) t) -> ('Seq.t, 'e) t
                  val filter_map :
                    'Seq.t ->
                    f:('-> ('Option.t, 'e) t) -> ('Seq.t, 'e) t
                end
              val ( >=> ) :
                ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
              val ( !! ) : '-> ('a, 'e) t
              val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val ( !$$ ) :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              module Let_syntax :
                sig
                  val return : '-> ('a, 'b) t
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  module Let_syntax :
                    sig
                      val return : '-> ('a, 'b) t
                      val bind :
                        ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                      val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                      val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                      module Open_on_rhs : sig  end
                    end
                end
              module Monad_infix :
                sig
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                end
              val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
              val return : '-> ('a, 'b) t
              val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
              val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
              val ignore_m : ('a, 'e) t -> (unit, 'e) t
              val all : ('a, 'e) t list -> ('a list, 'e) t
              val all_ignore : (unit, 'e) t list -> (unit, 'e) t
              module Syntax :
                sig
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  val ( >=> ) :
                    ('-> ('b, 'e) t) ->
                    ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                  val ( !! ) : '-> ('a, 'e) t
                  val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                  val ( !$$ ) :
                    ('-> '-> 'c) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) t ->
                    ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) t ->
                    ('b, 's) t ->
                    ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                end
              val put : '-> (unit, 's) t
              val get : unit -> ('s, 's) t
              val gets : ('-> 'r) -> ('r, 's) t
              val update : ('-> 's) -> (unit, 's) t
            end
          module T1 :
            functor (T : Core_kernel.Std.T) (M : Monad->
              sig
                type env = T.t
                type 'a m = 'M.t
                type 'a t =
                    (('a,
                      Monads.Std.Monad.State.Multi.T1.env
                      Monads.Std.Monad.State.Multi.contexts)
                     Monads.Std.Monad.State.storage
                     Monads.Std.Monad.State.Multi.T1.m,
                     Monads.Std.Monad.State.Multi.T1.env
                     Monads.Std.Monad.State.Multi.contexts)
                    Monads.Std.Monad.State.state
                type 'a e =
                    Monads.Std.Monad.State.Multi.T1.env ->
                    ('a * Monads.Std.Monad.State.Multi.T1.env)
                    Monads.Std.Monad.State.Multi.T1.m
              end
          module T2 :
            functor (M : Monad->
              sig
                type 'a m = 'M.t
                type ('a, 'e) t =
                    (('a, 'Monads.Std.Monad.State.Multi.contexts)
                     Monads.Std.Monad.State.storage
                     Monads.Std.Monad.State.Multi.T2.m,
                     'Monads.Std.Monad.State.Multi.contexts)
                    Monads.Std.Monad.State.state
                type ('a, 'e) e =
                    '-> ('a * 'e) Monads.Std.Monad.State.Multi.T2.m
              end
          module Make :
            functor (T : Core_kernel.Std.T) (M : Monad->
              sig
                val global : id
                val fork : unit -> unit T1(T)(M).t
                val switch : id -> unit T1(T)(M).t
                val parent : unit -> id T1(T)(M).t
                val ancestor : id List.t -> id T1(T)(M).t
                val current : unit -> id T1(T)(M).t
                val kill : id -> unit T1(T)(M).t
                val forks : unit -> id Seq.t T1(T)(M).t
                val status : id -> status T1(T)(M).t
                val lift : 'M.t -> 'T1(T)(M).t
                val run : 'T1(T)(M).t -> 'T1(T)(M).e
                val void : 'T1(T)(M).t -> unit T1(T)(M).t
                val sequence : unit T1(T)(M).t List.t -> unit T1(T)(M).t
                val forever : 'T1(T)(M).t -> 'T1(T)(M).t
                module Fn :
                  sig
                    val id : '-> 'T1(T)(M).t
                    val ignore : 'T1(T)(M).t -> unit T1(T)(M).t
                    val nothing : unit -> unit T1(T)(M).t
                    val non :
                      ('-> bool T1(T)(M).t) -> '-> bool T1(T)(M).t
                    val apply_n_times :
                      n:int -> ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                    val compose :
                      ('-> 'T1(T)(M).t) ->
                      ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                  end
                module Pair :
                  sig
                    val fst : ('a * 'b) T1(T)(M).t -> 'T1(T)(M).t
                    val snd : ('a * 'b) T1(T)(M).t -> 'T1(T)(M).t
                  end
                module Triple :
                  sig
                    val fst : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                    val snd : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                    val trd : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                  end
                module Lift :
                  sig
                    val nullary : '-> 'T1(T)(M).t
                    val unary : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val binary :
                      ('-> '-> 'c) ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ternary :
                      ('-> '-> '-> 'd) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val quaternary :
                      ('-> '-> '-> '-> 'e) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val quinary :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                  end
                module Exn :
                  sig
                    val expect :
                      ?finally:(unit -> unit T1(T)(M).t) ->
                      f:(unit -> 'T1(T)(M).t) ->
                      catch:(exn -> 'T1(T)(M).t) -> 'T1(T)(M).t
                  end
                module Collection :
                  sig
                    module type S =
                      sig
                        type 'a t
                        val all : 'T1(T)(M).t t -> 'a t T1(T)(M).t
                        val all_ignore : 'T1(T)(M).t t -> unit T1(T)(M).t
                        val sequence : unit T1(T)(M).t t -> unit T1(T)(M).t
                        val map :
                          'a t -> f:('-> 'T1(T)(M).t) -> 'b t T1(T)(M).t
                        val iter :
                          'a t ->
                          f:('-> unit T1(T)(M).t) -> unit T1(T)(M).t
                        val fold :
                          'a t ->
                          init:'->
                          f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val fold_left :
                          'a t ->
                          init:'->
                          f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val fold_right :
                          'a t ->
                          f:('-> '-> 'T1(T)(M).t) ->
                          init:'-> 'T1(T)(M).t
                        val reduce :
                          'a t ->
                          f:('-> '-> 'T1(T)(M).t) ->
                          'Option.t T1(T)(M).t
                        val exists :
                          'a t ->
                          f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                        val for_all :
                          'a t ->
                          f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                        val count :
                          'a t -> f:('-> bool T1(T)(M).t) -> int T1(T)(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b t -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val find :
                          'a t ->
                          f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                        val find_map :
                          'a t ->
                          f:('-> 'Option.t T1(T)(M).t) ->
                          'Option.t T1(T)(M).t
                        val filter :
                          'a t ->
                          f:('-> bool T1(T)(M).t) -> 'a t T1(T)(M).t
                        val filter_map :
                          'a t ->
                          f:('-> 'Option.t T1(T)(M).t) -> 'b t T1(T)(M).t
                      end
                    module Eager :
                      functor (T : Collection.Eager->
                        sig
                          val all : 'T1(T)(M).t T.t -> 'T.t T1(T)(M).t
                          val all_ignore :
                            'T1(T)(M).t T.t -> unit T1(T)(M).t
                          val sequence :
                            unit T1(T)(M).t T.t -> unit T1(T)(M).t
                          val map :
                            'T.t ->
                            f:('-> 'T1(T)(M).t) -> 'T.t T1(T)(M).t
                          val iter :
                            'T.t ->
                            f:('-> unit T1(T)(M).t) -> unit T1(T)(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> 'T1(T)(M).t) ->
                            init:'-> 'T1(T)(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> 'T1(T)(M).t) ->
                            'Option.t T1(T)(M).t
                          val exists :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                          val for_all :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                          val count :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) -> int T1(T)(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t ->
                            f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                          val find :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) ->
                            'Option.t T1(T)(M).t
                          val find_map :
                            'T.t ->
                            f:('-> 'Option.t T1(T)(M).t) ->
                            'Option.t T1(T)(M).t
                          val filter :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) -> 'T.t T1(T)(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> 'Option.t T1(T)(M).t) ->
                            'T.t T1(T)(M).t
                        end
                    module Delay :
                      functor (T : Collection.Delay->
                        sig
                          val all : 'T1(T)(M).t T.t -> 'T.t T1(T)(M).t
                          val all_ignore :
                            'T1(T)(M).t T.t -> unit T1(T)(M).t
                          val sequence :
                            unit T1(T)(M).t T.t -> unit T1(T)(M).t
                          val map :
                            'T.t ->
                            f:('-> 'T1(T)(M).t) -> 'T.t T1(T)(M).t
                          val iter :
                            'T.t ->
                            f:('-> unit T1(T)(M).t) -> unit T1(T)(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> 'T1(T)(M).t) ->
                            init:'-> 'T1(T)(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> 'T1(T)(M).t) ->
                            'Option.t T1(T)(M).t
                          val exists :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                          val for_all :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                          val count :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) -> int T1(T)(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t ->
                            f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                          val find :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) ->
                            'Option.t T1(T)(M).t
                          val find_map :
                            'T.t ->
                            f:('-> 'Option.t T1(T)(M).t) ->
                            'Option.t T1(T)(M).t
                          val filter :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) -> 'T.t T1(T)(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> 'Option.t T1(T)(M).t) ->
                            'T.t T1(T)(M).t
                        end
                  end
                module List :
                  sig
                    val all : 'T1(T)(M).t List.t -> 'List.t T1(T)(M).t
                    val all_ignore : 'T1(T)(M).t List.t -> unit T1(T)(M).t
                    val sequence : unit T1(T)(M).t List.t -> unit T1(T)(M).t
                    val map :
                      'List.t ->
                      f:('-> 'T1(T)(M).t) -> 'List.t T1(T)(M).t
                    val iter :
                      'List.t ->
                      f:('-> unit T1(T)(M).t) -> unit T1(T)(M).t
                    val fold :
                      'List.t ->
                      init:'->
                      f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val fold_left :
                      'List.t ->
                      init:'->
                      f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val fold_right :
                      'List.t ->
                      f:('-> '-> 'T1(T)(M).t) ->
                      init:'-> 'T1(T)(M).t
                    val reduce :
                      'List.t ->
                      f:('-> '-> 'T1(T)(M).t) -> 'Option.t T1(T)(M).t
                    val exists :
                      'List.t ->
                      f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                    val for_all :
                      'List.t ->
                      f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                    val count :
                      'List.t ->
                      f:('-> bool T1(T)(M).t) -> int T1(T)(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'List.t -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val find :
                      'List.t ->
                      f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                    val find_map :
                      'List.t ->
                      f:('-> 'Option.t T1(T)(M).t) ->
                      'Option.t T1(T)(M).t
                    val filter :
                      'List.t ->
                      f:('-> bool T1(T)(M).t) -> 'List.t T1(T)(M).t
                    val filter_map :
                      'List.t ->
                      f:('-> 'Option.t T1(T)(M).t) ->
                      'List.t T1(T)(M).t
                  end
                module Seq :
                  sig
                    val all : 'T1(T)(M).t Seq.t -> 'Seq.t T1(T)(M).t
                    val all_ignore : 'T1(T)(M).t Seq.t -> unit T1(T)(M).t
                    val sequence : unit T1(T)(M).t Seq.t -> unit T1(T)(M).t
                    val map :
                      'Seq.t ->
                      f:('-> 'T1(T)(M).t) -> 'Seq.t T1(T)(M).t
                    val iter :
                      'Seq.t ->
                      f:('-> unit T1(T)(M).t) -> unit T1(T)(M).t
                    val fold :
                      'Seq.t ->
                      init:'->
                      f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val fold_left :
                      'Seq.t ->
                      init:'->
                      f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val fold_right :
                      'Seq.t ->
                      f:('-> '-> 'T1(T)(M).t) ->
                      init:'-> 'T1(T)(M).t
                    val reduce :
                      'Seq.t ->
                      f:('-> '-> 'T1(T)(M).t) -> 'Option.t T1(T)(M).t
                    val exists :
                      'Seq.t ->
                      f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                    val for_all :
                      'Seq.t ->
                      f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                    val count :
                      'Seq.t -> f:('-> bool T1(T)(M).t) -> int T1(T)(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'Seq.t -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val find :
                      'Seq.t ->
                      f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                    val find_map :
                      'Seq.t ->
                      f:('-> 'Option.t T1(T)(M).t) ->
                      'Option.t T1(T)(M).t
                    val filter :
                      'Seq.t ->
                      f:('-> bool T1(T)(M).t) -> 'Seq.t T1(T)(M).t
                    val filter_map :
                      'Seq.t ->
                      f:('-> 'Option.t T1(T)(M).t) -> 'Seq.t T1(T)(M).t
                  end
                val ( >=> ) :
                  ('-> 'T1(T)(M).t) ->
                  ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                val ( !! ) : '-> 'T1(T)(M).t
                val ( !$ ) : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( >>= ) :
                  'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val ( >>| ) : 'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                module Monad_infix :
                  sig
                    val ( >>= ) :
                      'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val ( >>| ) :
                      'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                  end
                val bind :
                  'T1(T)(M).t -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val return : '-> 'T1(T)(M).t
                val map : 'T1(T)(M).t -> f:('-> 'b) -> 'T1(T)(M).t
                val join : 'T1(T)(M).t T1(T)(M).t -> 'T1(T)(M).t
                val ignore_m : 'T1(T)(M).t -> unit T1(T)(M).t
                val all : 'T1(T)(M).t list -> 'a list T1(T)(M).t
                val all_ignore : unit T1(T)(M).t list -> unit T1(T)(M).t
                module Let_syntax :
                  sig
                    val return : '-> 'T1(T)(M).t
                    val ( >>= ) :
                      'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val ( >>| ) :
                      'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                    module Let_syntax :
                      sig
                        val return : '-> 'T1(T)(M).t
                        val bind :
                          'T1(T)(M).t ->
                          f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val map :
                          'T1(T)(M).t -> f:('-> 'b) -> 'T1(T)(M).t
                        val both :
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> ('a * 'b) T1(T)(M).t
                        module Open_on_rhs : sig  end
                      end
                  end
                module Syntax :
                  sig
                    val ( >>= ) :
                      'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val ( >>| ) :
                      'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                    val ( >=> ) :
                      ('-> 'T1(T)(M).t) ->
                      ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                    val ( !! ) : '-> 'T1(T)(M).t
                    val ( !$ ) : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                  end
                val put : T.t -> unit T1(T)(M).t
                val get : unit -> T.t T1(T)(M).t
                val gets : (T.t -> 'r) -> 'T1(T)(M).t
                val update : (T.t -> T.t) -> unit T1(T)(M).t
              end
          module Make2 :
            functor (M : Monad->
              sig
                val global : id
                val fork : unit -> (unit, 'e) T2(M).t
                val switch : id -> (unit, 'e) T2(M).t
                val parent : unit -> (id, 'e) T2(M).t
                val ancestor : id List.t -> (id, 'e) T2(M).t
                val current : unit -> (id, 'e) T2(M).t
                val kill : id -> (unit, 'e) T2(M).t
                val forks : unit -> (id Seq.t, 'e) T2(M).t
                val status : id -> (status, 'e) T2(M).t
                val lift : 'M.t -> ('a, 'e) T2(M).t
                val run : ('a, 'e) T2(M).t -> ('a, 'e) T2(M).e
                val void : ('a, 'e) T2(M).t -> (unit, 'e) T2(M).t
                val sequence :
                  (unit, 'e) T2(M).t List.t -> (unit, 'e) T2(M).t
                val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                module Fn :
                  sig
                    val id : '-> ('a, 'e) T2(M).t
                    val ignore : ('a, 'e) T2(M).t -> (unit, 'e) T2(M).t
                    val nothing : unit -> (unit, 'e) T2(M).t
                    val non :
                      ('-> (bool, 'e) T2(M).t) -> '-> (bool, 'e) T2(M).t
                    val apply_n_times :
                      n:int ->
                      ('-> ('a, 'e) T2(M).t) -> '-> ('a, 'e) T2(M).t
                    val compose :
                      ('-> ('c, 'e) T2(M).t) ->
                      ('-> ('b, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                  end
                module Pair :
                  sig
                    val fst : ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
                    val snd : ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
                  end
                module Triple :
                  sig
                    val fst : ('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
                    val snd : ('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val trd : ('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
                  end
                module Lift :
                  sig
                    val nullary : '-> ('a, 'e) T2(M).t
                    val unary :
                      ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val binary :
                      ('-> '-> 'c) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                    val ternary :
                      ('-> '-> '-> 'd) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t ->
                      ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                    val quaternary :
                      ('-> '-> '-> '-> 'e) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                    val quinary :
                      ('-> '-> '-> '-> '-> 'f) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t ->
                      ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                  end
                module Exn :
                  sig
                    val expect :
                      ?finally:(unit -> (unit, 's) T2(M).t) ->
                      f:(unit -> ('a, 's) T2(M).t) ->
                      catch:(exn -> ('a, 's) T2(M).t) -> ('a, 's) T2(M).t
                  end
                module Collection :
                  sig
                    module type S =
                      sig
                        type 'a t
                        val all : ('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
                        val all_ignore :
                          ('a, 'e) T2(M).t t -> (unit, 'e) T2(M).t
                        val sequence :
                          (unit, 'e) T2(M).t t -> (unit, 'e) T2(M).t
                        val map :
                          'a t ->
                          f:('-> ('b, 'e) T2(M).t) -> ('b t, 'e) T2(M).t
                        val iter :
                          'a t ->
                          f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                        val fold :
                          'a t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_left :
                          'a t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_right :
                          'a t ->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          init:'-> ('b, 'e) T2(M).t
                        val reduce :
                          'a t ->
                          f:('-> '-> ('a, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val exists :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val for_all :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val count :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b t ->
                          f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                        val find :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val find_map :
                          'a t ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val filter :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) -> ('a t, 'e) T2(M).t
                        val filter_map :
                          'a t ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('b t, 'e) T2(M).t
                      end
                    module Eager :
                      functor (T : Collection.Eager->
                        sig
                          val all :
                            ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                          val all_ignore :
                            ('a, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                          val sequence :
                            (unit, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                          val map :
                            'T.t ->
                            f:('-> ('b, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val iter :
                            'T.t ->
                            f:('-> (unit, 'e) T2(M).t) ->
                            (unit, 'e) T2(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            init:'-> ('b, 'e) T2(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> ('a, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val exists :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val for_all :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val count :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t ->
                            f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                          val find :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val find_map :
                            'T.t ->
                            f:('-> ('Option.t, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val filter :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> ('Option.t, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                        end
                    module Delay :
                      functor (T : Collection.Delay->
                        sig
                          val all :
                            ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                          val all_ignore :
                            ('a, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                          val sequence :
                            (unit, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                          val map :
                            'T.t ->
                            f:('-> ('b, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val iter :
                            'T.t ->
                            f:('-> (unit, 'e) T2(M).t) ->
                            (unit, 'e) T2(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            init:'-> ('b, 'e) T2(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> ('a, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val exists :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val for_all :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val count :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t ->
                            f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                          val find :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val find_map :
                            'T.t ->
                            f:('-> ('Option.t, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val filter :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> ('Option.t, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                        end
                  end
                module List :
                  sig
                    val all :
                      ('a, 'e) T2(M).t List.t -> ('List.t, 'e) T2(M).t
                    val all_ignore :
                      ('a, 'e) T2(M).t List.t -> (unit, 'e) T2(M).t
                    val sequence :
                      (unit, 'e) T2(M).t List.t -> (unit, 'e) T2(M).t
                    val map :
                      'List.t ->
                      f:('-> ('b, 'e) T2(M).t) -> ('List.t, 'e) T2(M).t
                    val iter :
                      'List.t ->
                      f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                    val fold :
                      'List.t ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_left :
                      'List.t ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_right :
                      'List.t ->
                      f:('-> '-> ('b, 'e) T2(M).t) ->
                      init:'-> ('b, 'e) T2(M).t
                    val reduce :
                      'List.t ->
                      f:('-> '-> ('a, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val exists :
                      'List.t ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val for_all :
                      'List.t ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val count :
                      'List.t ->
                      f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'List.t ->
                      f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                    val find :
                      'List.t ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val find_map :
                      'List.t ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val filter :
                      'List.t ->
                      f:('-> (bool, 'e) T2(M).t) -> ('List.t, 'e) T2(M).t
                    val filter_map :
                      'List.t ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('List.t, 'e) T2(M).t
                  end
                module Seq :
                  sig
                    val all :
                      ('a, 'e) T2(M).t Seq.t -> ('Seq.t, 'e) T2(M).t
                    val all_ignore :
                      ('a, 'e) T2(M).t Seq.t -> (unit, 'e) T2(M).t
                    val sequence :
                      (unit, 'e) T2(M).t Seq.t -> (unit, 'e) T2(M).t
                    val map :
                      'Seq.t ->
                      f:('-> ('b, 'e) T2(M).t) -> ('Seq.t, 'e) T2(M).t
                    val iter :
                      'Seq.t ->
                      f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                    val fold :
                      'Seq.t ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_left :
                      'Seq.t ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_right :
                      'Seq.t ->
                      f:('-> '-> ('b, 'e) T2(M).t) ->
                      init:'-> ('b, 'e) T2(M).t
                    val reduce :
                      'Seq.t ->
                      f:('-> '-> ('a, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val exists :
                      'Seq.t ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val for_all :
                      'Seq.t ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val count :
                      'Seq.t ->
                      f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'Seq.t ->
                      f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                    val find :
                      'Seq.t ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val find_map :
                      'Seq.t ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val filter :
                      'Seq.t ->
                      f:('-> (bool, 'e) T2(M).t) -> ('Seq.t, 'e) T2(M).t
                    val filter_map :
                      'Seq.t ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('Seq.t, 'e) T2(M).t
                  end
                val ( >=> ) :
                  ('-> ('b, 'e) T2(M).t) ->
                  ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                val ( !! ) : '-> ('a, 'e) T2(M).t
                val ( !$ ) :
                  ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) ->
                  ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  ('a, 'e) T2(M).t ->
                  ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t -> ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t ->
                  ('d, 's) T2(M).t -> ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                val ( >>= ) :
                  ('a, 'e) T2(M).t ->
                  ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val ( >>| ) :
                  ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                module Let_syntax :
                  sig
                    val return : '-> ('a, 'b) T2(M).t
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                    module Let_syntax :
                      sig
                        val return : '-> ('a, 'b) T2(M).t
                        val bind :
                          ('a, 'e) T2(M).t ->
                          f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val map :
                          ('a, 'e) T2(M).t ->
                          f:('-> 'b) -> ('b, 'e) T2(M).t
                        val both :
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
                        module Open_on_rhs : sig  end
                      end
                  end
                module Monad_infix :
                  sig
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                  end
                val bind :
                  ('a, 'e) T2(M).t ->
                  f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val return : '-> ('a, 'b) T2(M).t
                val map :
                  ('a, 'e) T2(M).t -> f:('-> 'b) -> ('b, 'e) T2(M).t
                val join : (('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
                val ignore_m : ('a, 'e) T2(M).t -> (unit, 'e) T2(M).t
                val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                val all_ignore :
                  (unit, 'e) T2(M).t list -> (unit, 'e) T2(M).t
                module Syntax :
                  sig
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                    val ( >=> ) :
                      ('-> ('b, 'e) T2(M).t) ->
                      ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                    val ( !! ) : '-> ('a, 'e) T2(M).t
                    val ( !$ ) :
                      ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t ->
                      ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t ->
                      ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                  end
                val put : '-> (unit, 's) T2(M).t
                val get : unit -> ('s, 's) T2(M).t
                val gets : ('-> 'r) -> ('r, 's) T2(M).t
                val update : ('-> 's) -> (unit, 's) T2(M).t
              end
        end
      type ('a, 'e) t = (('a, 'e) storage, 'e) state
      type 'a m = 'a
      type ('a, 'e) e = '-> 'a * 'e
      val lift : '-> ('a, 'e) t
      val run : ('a, 'e) t -> ('a, 'e) e
      val void : ('a, 'e) t -> (unit, 'e) t
      val sequence : (unit, 'e) t List.t -> (unit, 'e) t
      val forever : ('a, 'e) t -> ('b, 'e) t
      module Fn :
        sig
          val id : '-> ('a, 'e) t
          val ignore : ('a, 'e) t -> (unit, 'e) t
          val nothing : unit -> (unit, 'e) t
          val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
          val apply_n_times : n:int -> ('-> ('a, 'e) t) -> '-> ('a, 'e) t
          val compose :
            ('-> ('c, 'e) t) -> ('-> ('b, 'e) t) -> '-> ('c, 'e) t
        end
      module Pair :
        sig
          val fst : ('a * 'b, 'e) t -> ('a, 'e) t
          val snd : ('a * 'b, 'e) t -> ('b, 'e) t
        end
      module Triple :
        sig
          val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
          val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
          val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
        end
      module Lift :
        sig
          val nullary : '-> ('a, 'e) t
          val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
          val binary :
            ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
          val ternary :
            ('-> '-> '-> 'd) ->
            ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
          val quaternary :
            ('-> '-> '-> '-> 'e) ->
            ('a, 's) t ->
            ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
          val quinary :
            ('-> '-> '-> '-> '-> 'f) ->
            ('a, 's) t ->
            ('b, 's) t ->
            ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
        end
      module Exn :
        sig
          val expect :
            ?finally:(unit -> (unit, 's) t) ->
            f:(unit -> ('a, 's) t) -> catch:(exn -> ('a, 's) t) -> ('a, 's) t
        end
      module Collection :
        sig
          module type S =
            sig
              type 'a t
              val all : ('a, 'e) t t -> ('a t, 'e) t
              val all_ignore : ('a, 'e) t t -> (unit, 'e) t
              val sequence : (unit, 'e) t t -> (unit, 'e) t
              val map : 'a t -> f:('-> ('b, 'e) t) -> ('b t, 'e) t
              val iter : 'a t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
              val fold :
                'a t -> init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_left :
                'a t -> init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_right :
                'a t -> f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
              val reduce :
                'a t -> f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
              val exists : 'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val for_all : 'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val count : 'a t -> f:('-> (bool, 'e) t) -> (int, 'e) t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'b t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
              val find :
                'a t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
              val find_map :
                'a t -> f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
              val filter : 'a t -> f:('-> (bool, 'e) t) -> ('a t, 'e) t
              val filter_map :
                'a t -> f:('-> ('Option.t, 'e) t) -> ('b t, 'e) t
            end
          module Eager :
            functor (T : Collection.Eager->
              sig
                val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                val all_ignore : ('a, 'e) t T.t -> (unit, 'e) t
                val sequence : (unit, 'e) t T.t -> (unit, 'e) t
                val map : 'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                val iter : 'T.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                val fold :
                  'T.t ->
                  init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                val fold_left :
                  'T.t ->
                  init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                val fold_right :
                  'T.t ->
                  f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                val reduce :
                  'T.t -> f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                val exists : 'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                val for_all :
                  'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                val count : 'T.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                val find :
                  'T.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                val find_map :
                  'T.t ->
                  f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                val filter :
                  'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                val filter_map :
                  'T.t -> f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
              end
          module Delay :
            functor (T : Collection.Delay->
              sig
                val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                val all_ignore : ('a, 'e) t T.t -> (unit, 'e) t
                val sequence : (unit, 'e) t T.t -> (unit, 'e) t
                val map : 'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                val iter : 'T.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                val fold :
                  'T.t ->
                  init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                val fold_left :
                  'T.t ->
                  init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                val fold_right :
                  'T.t ->
                  f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                val reduce :
                  'T.t -> f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                val exists : 'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                val for_all :
                  'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                val count : 'T.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                val find :
                  'T.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                val find_map :
                  'T.t ->
                  f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                val filter :
                  'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                val filter_map :
                  'T.t -> f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
              end
        end
      module List :
        sig
          val all : ('a, 'e) t List.t -> ('List.t, 'e) t
          val all_ignore : ('a, 'e) t List.t -> (unit, 'e) t
          val sequence : (unit, 'e) t List.t -> (unit, 'e) t
          val map : 'List.t -> f:('-> ('b, 'e) t) -> ('List.t, 'e) t
          val iter : 'List.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
          val fold :
            'List.t -> init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
          val fold_left :
            'List.t -> init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
          val fold_right :
            'List.t -> f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
          val reduce :
            'List.t -> f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
          val exists : 'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
          val for_all : 'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
          val count : 'List.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
          val map_reduce :
            (module Monoid.S with type t = 'a) ->
            'List.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
          val find :
            'List.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
          val find_map :
            'List.t -> f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
          val filter :
            'List.t -> f:('-> (bool, 'e) t) -> ('List.t, 'e) t
          val filter_map :
            'List.t -> f:('-> ('Option.t, 'e) t) -> ('List.t, 'e) t
        end
      module Seq :
        sig
          val all : ('a, 'e) t Seq.t -> ('Seq.t, 'e) t
          val all_ignore : ('a, 'e) t Seq.t -> (unit, 'e) t
          val sequence : (unit, 'e) t Seq.t -> (unit, 'e) t
          val map : 'Seq.t -> f:('-> ('b, 'e) t) -> ('Seq.t, 'e) t
          val iter : 'Seq.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
          val fold :
            'Seq.t -> init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
          val fold_left :
            'Seq.t -> init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
          val fold_right :
            'Seq.t -> f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
          val reduce :
            'Seq.t -> f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
          val exists : 'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
          val for_all : 'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
          val count : 'Seq.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
          val map_reduce :
            (module Monoid.S with type t = 'a) ->
            'Seq.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
          val find :
            'Seq.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
          val find_map :
            'Seq.t -> f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
          val filter : 'Seq.t -> f:('-> (bool, 'e) t) -> ('Seq.t, 'e) t
          val filter_map :
            'Seq.t -> f:('-> ('Option.t, 'e) t) -> ('Seq.t, 'e) t
        end
      val ( >=> ) :
        ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
      val ( !! ) : '-> ('a, 'e) t
      val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
      val ( !$$ ) :
        ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
      val ( !$$$ ) :
        ('-> '-> '-> 'd) ->
        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
      val ( !$$$$ ) :
        ('-> '-> '-> '-> 'e) ->
        ('a, 's) t -> ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
      val ( !$$$$$ ) :
        ('-> '-> '-> '-> '-> 'f) ->
        ('a, 's) t ->
        ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
      val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
      module Let_syntax :
        sig
          val return : '-> ('a, 'b) t
          val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
          val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
          module Let_syntax :
            sig
              val return : '-> ('a, 'b) t
              val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
              val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
              val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
              module Open_on_rhs : sig  end
            end
        end
      module Monad_infix :
        sig
          val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
          val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
        end
      val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
      val return : '-> ('a, 'b) t
      val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
      val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
      val ignore_m : ('a, 'e) t -> (unit, 'e) t
      val all : ('a, 'e) t list -> ('a list, 'e) t
      val all_ignore : (unit, 'e) t list -> (unit, 'e) t
      module Syntax :
        sig
          val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
          val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
          val ( >=> ) :
            ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
          val ( !! ) : '-> ('a, 'e) t
          val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
          val ( !$$ ) :
            ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
          val ( !$$$ ) :
            ('-> '-> '-> 'd) ->
            ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            ('a, 's) t ->
            ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            ('a, 's) t ->
            ('b, 's) t ->
            ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
        end
      val put : '-> (unit, 's) t
      val get : unit -> ('s, 's) t
      val gets : ('-> 'r) -> ('r, 's) t
      val update : ('-> 's) -> (unit, 's) t
      val eval : ('a, 'e) t -> '-> 'a
      val exec : ('a, 'e) t -> '-> 'e
      module T1 :
        functor (T : Core_kernel.Std.T) (M : Monad->
          sig
            type env = T.t
            type 'a m = 'M.t
            type 'a t =
                (('a, Monads.Std.Monad.State.T1.env)
                 Monads.Std.Monad.State.storage Monads.Std.Monad.State.T1.m,
                 Monads.Std.Monad.State.T1.env)
                Monads.Std.Monad.State.state
            type 'a e =
                Monads.Std.Monad.State.T1.env ->
                ('a * Monads.Std.Monad.State.T1.env)
                Monads.Std.Monad.State.T1.m
          end
      module T2 :
        functor (M : Monad->
          sig
            type 'a m = 'M.t
            type ('a, 'e) t =
                (('a, 'e) Monads.Std.Monad.State.storage
                 Monads.Std.Monad.State.T2.m, 'e)
                Monads.Std.Monad.State.state
            type ('a, 'e) e = '-> ('a * 'e) Monads.Std.Monad.State.T2.m
          end
      module Make :
        functor (T : Core_kernel.Std.T) (M : Monad->
          sig
            val lift : 'M.t -> 'T1(T)(M).t
            val run : 'T1(T)(M).t -> 'T1(T)(M).e
            val void : 'T1(T)(M).t -> unit T1(T)(M).t
            val sequence : unit T1(T)(M).t list -> unit T1(T)(M).t
            val forever : 'T1(T)(M).t -> 'T1(T)(M).t
            module Fn :
              sig
                val id : '-> 'T1(T)(M).t
                val ignore : 'T1(T)(M).t -> unit T1(T)(M).t
                val nothing : unit -> unit T1(T)(M).t
                val non : ('-> bool T1(T)(M).t) -> '-> bool T1(T)(M).t
                val apply_n_times :
                  n:int -> ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                val compose :
                  ('-> 'T1(T)(M).t) ->
                  ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
              end
            module Pair :
              sig
                val fst : ('a * 'b) T1(T)(M).t -> 'T1(T)(M).t
                val snd : ('a * 'b) T1(T)(M).t -> 'T1(T)(M).t
              end
            module Triple :
              sig
                val fst : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                val snd : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                val trd : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
              end
            module Lift :
              sig
                val nullary : '-> 'T1(T)(M).t
                val unary : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                val binary :
                  ('-> '-> 'c) ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ternary :
                  ('-> '-> '-> 'd) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val quaternary :
                  ('-> '-> '-> '-> 'e) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val quinary :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
              end
            module Exn :
              sig
                val expect :
                  ?finally:(unit -> unit T1(T)(M).t) ->
                  f:(unit -> 'T1(T)(M).t) ->
                  catch:(exn -> 'T1(T)(M).t) -> 'T1(T)(M).t
              end
            module Collection :
              sig
                module type S =
                  sig
                    type 'a t
                    val all : 'T1(T)(M).t t -> 'a t T1(T)(M).t
                    val all_ignore : 'T1(T)(M).t t -> unit T1(T)(M).t
                    val sequence : unit T1(T)(M).t t -> unit T1(T)(M).t
                    val map :
                      'a t -> f:('-> 'T1(T)(M).t) -> 'b t T1(T)(M).t
                    val iter :
                      'a t -> f:('-> unit T1(T)(M).t) -> unit T1(T)(M).t
                    val fold :
                      'a t ->
                      init:'->
                      f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val fold_left :
                      'a t ->
                      init:'->
                      f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val fold_right :
                      'a t ->
                      f:('-> '-> 'T1(T)(M).t) ->
                      init:'-> 'T1(T)(M).t
                    val reduce :
                      'a t ->
                      f:('-> '-> 'T1(T)(M).t) -> 'Option.t T1(T)(M).t
                    val exists :
                      'a t -> f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                    val for_all :
                      'a t -> f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                    val count :
                      'a t -> f:('-> bool T1(T)(M).t) -> int T1(T)(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b t -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val find :
                      'a t ->
                      f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                    val find_map :
                      'a t ->
                      f:('-> 'Option.t T1(T)(M).t) ->
                      'Option.t T1(T)(M).t
                    val filter :
                      'a t -> f:('-> bool T1(T)(M).t) -> 'a t T1(T)(M).t
                    val filter_map :
                      'a t ->
                      f:('-> 'Option.t T1(T)(M).t) -> 'b t T1(T)(M).t
                  end
                module Eager :
                  functor (T : Collection.Eager->
                    sig
                      val all : 'T1(T)(M).t T.t -> 'T.t T1(T)(M).t
                      val all_ignore : 'T1(T)(M).t T.t -> unit T1(T)(M).t
                      val sequence : unit T1(T)(M).t T.t -> unit T1(T)(M).t
                      val map :
                        'T.t ->
                        f:('-> 'T1(T)(M).t) -> 'T.t T1(T)(M).t
                      val iter :
                        'T.t ->
                        f:('-> unit T1(T)(M).t) -> unit T1(T)(M).t
                      val fold :
                        'T.t ->
                        init:'->
                        f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                      val fold_left :
                        'T.t ->
                        init:'->
                        f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> 'T1(T)(M).t) ->
                        init:'-> 'T1(T)(M).t
                      val reduce :
                        'T.t ->
                        f:('-> '-> 'T1(T)(M).t) ->
                        'Option.t T1(T)(M).t
                      val exists :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                      val for_all :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                      val count :
                        'T.t -> f:('-> bool T1(T)(M).t) -> int T1(T)(M).t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                      val find :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                      val find_map :
                        'T.t ->
                        f:('-> 'Option.t T1(T)(M).t) ->
                        'Option.t T1(T)(M).t
                      val filter :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> 'T.t T1(T)(M).t
                      val filter_map :
                        'T.t ->
                        f:('-> 'Option.t T1(T)(M).t) -> 'T.t T1(T)(M).t
                    end
                module Delay :
                  functor (T : Collection.Delay->
                    sig
                      val all : 'T1(T)(M).t T.t -> 'T.t T1(T)(M).t
                      val all_ignore : 'T1(T)(M).t T.t -> unit T1(T)(M).t
                      val sequence : unit T1(T)(M).t T.t -> unit T1(T)(M).t
                      val map :
                        'T.t ->
                        f:('-> 'T1(T)(M).t) -> 'T.t T1(T)(M).t
                      val iter :
                        'T.t ->
                        f:('-> unit T1(T)(M).t) -> unit T1(T)(M).t
                      val fold :
                        'T.t ->
                        init:'->
                        f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                      val fold_left :
                        'T.t ->
                        init:'->
                        f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> 'T1(T)(M).t) ->
                        init:'-> 'T1(T)(M).t
                      val reduce :
                        'T.t ->
                        f:('-> '-> 'T1(T)(M).t) ->
                        'Option.t T1(T)(M).t
                      val exists :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                      val for_all :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                      val count :
                        'T.t -> f:('-> bool T1(T)(M).t) -> int T1(T)(M).t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                      val find :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                      val find_map :
                        'T.t ->
                        f:('-> 'Option.t T1(T)(M).t) ->
                        'Option.t T1(T)(M).t
                      val filter :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> 'T.t T1(T)(M).t
                      val filter_map :
                        'T.t ->
                        f:('-> 'Option.t T1(T)(M).t) -> 'T.t T1(T)(M).t
                    end
              end
            module List :
              sig
                val all : 'T1(T)(M).t list -> 'a list T1(T)(M).t
                val all_ignore : 'T1(T)(M).t list -> unit T1(T)(M).t
                val sequence : unit T1(T)(M).t list -> unit T1(T)(M).t
                val map :
                  'a list -> f:('-> 'T1(T)(M).t) -> 'b list T1(T)(M).t
                val iter :
                  'a list -> f:('-> unit T1(T)(M).t) -> unit T1(T)(M).t
                val fold :
                  'a list ->
                  init:'-> f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val fold_left :
                  'a list ->
                  init:'-> f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val fold_right :
                  'a list ->
                  f:('-> '-> 'T1(T)(M).t) -> init:'-> 'T1(T)(M).t
                val reduce :
                  'a list ->
                  f:('-> '-> 'T1(T)(M).t) -> 'Option.t T1(T)(M).t
                val exists :
                  'a list -> f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                val for_all :
                  'a list -> f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                val count :
                  'a list -> f:('-> bool T1(T)(M).t) -> int T1(T)(M).t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'b list -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val find :
                  'a list ->
                  f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                val find_map :
                  'a list ->
                  f:('-> 'Option.t T1(T)(M).t) -> 'Option.t T1(T)(M).t
                val filter :
                  'a list -> f:('-> bool T1(T)(M).t) -> 'a list T1(T)(M).t
                val filter_map :
                  'a list ->
                  f:('-> 'Option.t T1(T)(M).t) -> 'b list T1(T)(M).t
              end
            module Seq :
              sig
                val all :
                  'T1(T)(M).t Core_kernel.Std.Sequence.t ->
                  'Core_kernel.Std.Sequence.t T1(T)(M).t
                val all_ignore :
                  'T1(T)(M).t Core_kernel.Std.Sequence.t -> unit T1(T)(M).t
                val sequence :
                  unit T1(T)(M).t Core_kernel.Std.Sequence.t ->
                  unit T1(T)(M).t
                val map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> 'T1(T)(M).t) ->
                  'Core_kernel.Std.Sequence.t T1(T)(M).t
                val iter :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> unit T1(T)(M).t) -> unit T1(T)(M).t
                val fold :
                  'Core_kernel.Std.Sequence.t ->
                  init:'-> f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val fold_left :
                  'Core_kernel.Std.Sequence.t ->
                  init:'-> f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val fold_right :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> '-> 'T1(T)(M).t) -> init:'-> 'T1(T)(M).t
                val reduce :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> '-> 'T1(T)(M).t) -> 'Option.t T1(T)(M).t
                val exists :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                val for_all :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                val count :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(T)(M).t) -> int T1(T)(M).t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val find :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                val find_map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> 'Option.t T1(T)(M).t) -> 'Option.t T1(T)(M).t
                val filter :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(T)(M).t) ->
                  'Core_kernel.Std.Sequence.t T1(T)(M).t
                val filter_map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> 'Option.t T1(T)(M).t) ->
                  'Core_kernel.Std.Sequence.t T1(T)(M).t
              end
            val ( >=> ) :
              ('-> 'T1(T)(M).t) ->
              ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
            val ( !! ) : '-> 'T1(T)(M).t
            val ( !$ ) : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
            val ( !$$ ) :
              ('-> '-> 'c) ->
              'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
            val ( !$$$ ) :
              ('-> '-> '-> 'd) ->
              'T1(T)(M).t ->
              'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
            val ( !$$$$ ) :
              ('-> '-> '-> '-> 'e) ->
              'T1(T)(M).t ->
              'T1(T)(M).t ->
              'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
            val ( !$$$$$ ) :
              ('-> '-> '-> '-> '-> 'f) ->
              'T1(T)(M).t ->
              'T1(T)(M).t ->
              'T1(T)(M).t ->
              'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
            val ( >>= ) :
              'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
            val ( >>| ) : 'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
            module Monad_infix :
              sig
                val ( >>= ) :
                  'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val ( >>| ) : 'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
              end
            val bind :
              'T1(T)(M).t -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
            val return : '-> 'T1(T)(M).t
            val map : 'T1(T)(M).t -> f:('-> 'b) -> 'T1(T)(M).t
            val join : 'T1(T)(M).t T1(T)(M).t -> 'T1(T)(M).t
            val ignore_m : 'T1(T)(M).t -> unit T1(T)(M).t
            val all : 'T1(T)(M).t list -> 'a list T1(T)(M).t
            val all_ignore : unit T1(T)(M).t list -> unit T1(T)(M).t
            module Let_syntax :
              sig
                val return : '-> 'T1(T)(M).t
                val ( >>= ) :
                  'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val ( >>| ) : 'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                module Let_syntax :
                  sig
                    val return : '-> 'T1(T)(M).t
                    val bind :
                      'T1(T)(M).t ->
                      f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val map : 'T1(T)(M).t -> f:('-> 'b) -> 'T1(T)(M).t
                    val both :
                      'T1(T)(M).t -> 'T1(T)(M).t -> ('a * 'b) T1(T)(M).t
                    module Open_on_rhs : sig  end
                  end
              end
            module Syntax :
              sig
                val ( >>= ) :
                  'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val ( >>| ) : 'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                val ( >=> ) :
                  ('-> 'T1(T)(M).t) ->
                  ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                val ( !! ) : '-> 'T1(T)(M).t
                val ( !$ ) : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
              end
            val put : T.t -> unit T1(T)(M).t
            val get : unit -> T.t T1(T)(M).t
            val gets : (T.t -> 'r) -> 'T1(T)(M).t
            val update : (T.t -> T.t) -> unit T1(T)(M).t
          end
      module Make2 :
        functor (M : Monad->
          sig
            val lift : 'M.t -> ('a, 'e) T2(M).t
            val run : ('a, 'e) T2(M).t -> ('a, 'e) T2(M).e
            val void : ('a, 'e) T2(M).t -> (unit, 'e) T2(M).t
            val sequence : (unit, 'e) T2(M).t list -> (unit, 'e) T2(M).t
            val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
            module Fn :
              sig
                val id : '-> ('a, 'e) T2(M).t
                val ignore : ('a, 'e) T2(M).t -> (unit, 'e) T2(M).t
                val nothing : unit -> (unit, 'e) T2(M).t
                val non :
                  ('-> (bool, 'e) T2(M).t) -> '-> (bool, 'e) T2(M).t
                val apply_n_times :
                  n:int -> ('-> ('a, 'e) T2(M).t) -> '-> ('a, 'e) T2(M).t
                val compose :
                  ('-> ('c, 'e) T2(M).t) ->
                  ('-> ('b, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
              end
            module Pair :
              sig
                val fst : ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
                val snd : ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
              end
            module Triple :
              sig
                val fst : ('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
                val snd : ('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
                val trd : ('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
              end
            module Lift :
              sig
                val nullary : '-> ('a, 'e) T2(M).t
                val unary :
                  ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                val binary :
                  ('-> '-> 'c) ->
                  ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                val ternary :
                  ('-> '-> '-> 'd) ->
                  ('a, 'e) T2(M).t ->
                  ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                val quaternary :
                  ('-> '-> '-> '-> 'e) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t -> ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                val quinary :
                  ('-> '-> '-> '-> '-> 'f) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t ->
                  ('d, 's) T2(M).t -> ('e, 's) T2(M).t -> ('f, 's) T2(M).t
              end
            module Exn :
              sig
                val expect :
                  ?finally:(unit -> (unit, 's) T2(M).t) ->
                  f:(unit -> ('a, 's) T2(M).t) ->
                  catch:(exn -> ('a, 's) T2(M).t) -> ('a, 's) T2(M).t
              end
            module Collection :
              sig
                module type S =
                  sig
                    type 'a t
                    val all : ('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
                    val all_ignore : ('a, 'e) T2(M).t t -> (unit, 'e) T2(M).t
                    val sequence : (unit, 'e) T2(M).t t -> (unit, 'e) T2(M).t
                    val map :
                      'a t ->
                      f:('-> ('b, 'e) T2(M).t) -> ('b t, 'e) T2(M).t
                    val iter :
                      'a t ->
                      f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                    val fold :
                      'a t ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_left :
                      'a t ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_right :
                      'a t ->
                      f:('-> '-> ('b, 'e) T2(M).t) ->
                      init:'-> ('b, 'e) T2(M).t
                    val reduce :
                      'a t ->
                      f:('-> '-> ('a, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val exists :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val for_all :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val count :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b t -> f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                    val find :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val find_map :
                      'a t ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val filter :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) -> ('a t, 'e) T2(M).t
                    val filter_map :
                      'a t ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('b t, 'e) T2(M).t
                  end
                module Eager :
                  functor (T : Collection.Eager->
                    sig
                      val all : ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                      val all_ignore :
                        ('a, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                      val sequence :
                        (unit, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                      val map :
                        'T.t ->
                        f:('-> ('b, 'e) T2(M).t) -> ('T.t, 'e) T2(M).t
                      val iter :
                        'T.t ->
                        f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                      val fold :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                      val fold_left :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> ('b, 'e) T2(M).t) ->
                        init:'-> ('b, 'e) T2(M).t
                      val reduce :
                        'T.t ->
                        f:('-> '-> ('a, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val exists :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                      val for_all :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                      val count :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t ->
                        f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                      val find :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val find_map :
                        'T.t ->
                        f:('-> ('Option.t, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val filter :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> ('T.t, 'e) T2(M).t
                      val filter_map :
                        'T.t ->
                        f:('-> ('Option.t, 'e) T2(M).t) ->
                        ('T.t, 'e) T2(M).t
                    end
                module Delay :
                  functor (T : Collection.Delay->
                    sig
                      val all : ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                      val all_ignore :
                        ('a, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                      val sequence :
                        (unit, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                      val map :
                        'T.t ->
                        f:('-> ('b, 'e) T2(M).t) -> ('T.t, 'e) T2(M).t
                      val iter :
                        'T.t ->
                        f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                      val fold :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                      val fold_left :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> ('b, 'e) T2(M).t) ->
                        init:'-> ('b, 'e) T2(M).t
                      val reduce :
                        'T.t ->
                        f:('-> '-> ('a, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val exists :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                      val for_all :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                      val count :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t ->
                        f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                      val find :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val find_map :
                        'T.t ->
                        f:('-> ('Option.t, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val filter :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> ('T.t, 'e) T2(M).t
                      val filter_map :
                        'T.t ->
                        f:('-> ('Option.t, 'e) T2(M).t) ->
                        ('T.t, 'e) T2(M).t
                    end
              end
            module List :
              sig
                val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                val all_ignore : ('a, 'e) T2(M).t list -> (unit, 'e) T2(M).t
                val sequence : (unit, 'e) T2(M).t list -> (unit, 'e) T2(M).t
                val map :
                  'a list ->
                  f:('-> ('b, 'e) T2(M).t) -> ('b list, 'e) T2(M).t
                val iter :
                  'a list ->
                  f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                val fold :
                  'a list ->
                  init:'->
                  f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val fold_left :
                  'a list ->
                  init:'->
                  f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val fold_right :
                  'a list ->
                  f:('-> '-> ('b, 'e) T2(M).t) ->
                  init:'-> ('b, 'e) T2(M).t
                val reduce :
                  'a list ->
                  f:('-> '-> ('a, 'e) T2(M).t) ->
                  ('Option.t, 'e) T2(M).t
                val exists :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                val for_all :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                val count :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'b list -> f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                val find :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> ('Option.t, 'e) T2(M).t
                val find_map :
                  'a list ->
                  f:('-> ('Option.t, 'e) T2(M).t) ->
                  ('Option.t, 'e) T2(M).t
                val filter :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> ('a list, 'e) T2(M).t
                val filter_map :
                  'a list ->
                  f:('-> ('Option.t, 'e) T2(M).t) ->
                  ('b list, 'e) T2(M).t
              end
            module Seq :
              sig
                val all :
                  ('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                  ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                val all_ignore :
                  ('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                  (unit, 'e) T2(M).t
                val sequence :
                  (unit, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                  (unit, 'e) T2(M).t
                val map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> ('b, 'e) T2(M).t) ->
                  ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                val iter :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                val fold :
                  'Core_kernel.Std.Sequence.t ->
                  init:'->
                  f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val fold_left :
                  'Core_kernel.Std.Sequence.t ->
                  init:'->
                  f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val fold_right :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> '-> ('b, 'e) T2(M).t) ->
                  init:'-> ('b, 'e) T2(M).t
                val reduce :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> '-> ('a, 'e) T2(M).t) ->
                  ('Option.t, 'e) T2(M).t
                val exists :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                val for_all :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                val count :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                val find :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) -> ('Option.t, 'e) T2(M).t
                val find_map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> ('Option.t, 'e) T2(M).t) ->
                  ('Option.t, 'e) T2(M).t
                val filter :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) ->
                  ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                val filter_map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> ('Option.t, 'e) T2(M).t) ->
                  ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
              end
            val ( >=> ) :
              ('-> ('b, 'e) T2(M).t) ->
              ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
            val ( !! ) : '-> ('a, 'e) T2(M).t
            val ( !$ ) : ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
            val ( !$$ ) :
              ('-> '-> 'c) ->
              ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
            val ( !$$$ ) :
              ('-> '-> '-> 'd) ->
              ('a, 'e) T2(M).t ->
              ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
            val ( !$$$$ ) :
              ('-> '-> '-> '-> 'e) ->
              ('a, 's) T2(M).t ->
              ('b, 's) T2(M).t ->
              ('c, 's) T2(M).t -> ('d, 's) T2(M).t -> ('e, 's) T2(M).t
            val ( !$$$$$ ) :
              ('-> '-> '-> '-> '-> 'f) ->
              ('a, 's) T2(M).t ->
              ('b, 's) T2(M).t ->
              ('c, 's) T2(M).t ->
              ('d, 's) T2(M).t -> ('e, 's) T2(M).t -> ('f, 's) T2(M).t
            val ( >>= ) :
              ('a, 'e) T2(M).t ->
              ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
            val ( >>| ) : ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
            module Let_syntax :
              sig
                val return : '-> ('a, 'b) T2(M).t
                val ( >>= ) :
                  ('a, 'e) T2(M).t ->
                  ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val ( >>| ) :
                  ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                module Let_syntax :
                  sig
                    val return : '-> ('a, 'b) T2(M).t
                    val bind :
                      ('a, 'e) T2(M).t ->
                      f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val map :
                      ('a, 'e) T2(M).t -> f:('-> 'b) -> ('b, 'e) T2(M).t
                    val both :
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
                    module Open_on_rhs : sig  end
                  end
              end
            module Monad_infix :
              sig
                val ( >>= ) :
                  ('a, 'e) T2(M).t ->
                  ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val ( >>| ) :
                  ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
              end
            val bind :
              ('a, 'e) T2(M).t ->
              f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
            val return : '-> ('a, 'b) T2(M).t
            val map : ('a, 'e) T2(M).t -> f:('-> 'b) -> ('b, 'e) T2(M).t
            val join : (('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
            val ignore_m : ('a, 'e) T2(M).t -> (unit, 'e) T2(M).t
            val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
            val all_ignore : (unit, 'e) T2(M).t list -> (unit, 'e) T2(M).t
            module Syntax :
              sig
                val ( >>= ) :
                  ('a, 'e) T2(M).t ->
                  ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val ( >>| ) :
                  ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                val ( >=> ) :
                  ('-> ('b, 'e) T2(M).t) ->
                  ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                val ( !! ) : '-> ('a, 'e) T2(M).t
                val ( !$ ) :
                  ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) ->
                  ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  ('a, 'e) T2(M).t ->
                  ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t -> ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t ->
                  ('d, 's) T2(M).t -> ('e, 's) T2(M).t -> ('f, 's) T2(M).t
              end
            val put : '-> (unit, 's) T2(M).t
            val get : unit -> ('s, 's) T2(M).t
            val gets : ('-> 'r) -> ('r, 's) T2(M).t
            val update : ('-> 's) -> (unit, 's) T2(M).t
          end
    end
  module Fun :
    sig
      module type S =
        sig
          type 'a t
          type 'a m
          type 'a e
          val lift : 'a m -> 'a t
          val run : 'a t -> 'a e
          val void : 'a t -> unit t
          val sequence : unit t List.t -> unit t
          val forever : 'a t -> 'b t
          module Fn :
            sig
              val id : '-> 'a t
              val ignore : 'a t -> unit t
              val nothing : unit -> unit t
              val non : ('-> bool t) -> '-> bool t
              val apply_n_times : n:int -> ('-> 'a t) -> '-> 'a t
              val compose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
            end
          module Pair :
            sig
              val fst : ('a * 'b) t -> 'a t
              val snd : ('a * 'b) t -> 'b t
            end
          module Triple :
            sig
              val fst : ('a * 'b * 'c) t -> 'a t
              val snd : ('a * 'b * 'c) t -> 'b t
              val trd : ('a * 'b * 'c) t -> 'c t
            end
          module Lift :
            sig
              val nullary : '-> 'a t
              val unary : ('-> 'b) -> 'a t -> 'b t
              val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ternary :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val quaternary :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val quinary :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
            end
          module Exn :
            sig
              val expect :
                ?finally:(unit -> unit t) ->
                f:(unit -> 'a t) -> catch:(exn -> 'a t) -> 'a t
            end
          module Collection :
            sig
              module type S =
                sig
                  type 'a t
                  val all : 'a t t -> 'a t t
                  val all_ignore : 'a t t -> unit t
                  val sequence : unit t t -> unit t
                  val map : 'a t -> f:('-> 'b t) -> 'b t t
                  val iter : 'a t -> f:('-> unit t) -> unit t
                  val fold : 'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce : 'a t -> f:('-> '-> 'a t) -> 'Option.t t
                  val exists : 'a t -> f:('-> bool t) -> bool t
                  val for_all : 'a t -> f:('-> bool t) -> bool t
                  val count : 'a t -> f:('-> bool t) -> int t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b t -> f:('-> 'a t) -> 'a t
                  val find : 'a t -> f:('-> bool t) -> 'Option.t t
                  val find_map :
                    'a t -> f:('-> 'Option.t t) -> 'Option.t t
                  val filter : 'a t -> f:('-> bool t) -> 'a t t
                  val filter_map : 'a t -> f:('-> 'Option.t t) -> 'b t t
                end
              module Eager :
                functor (T : Collection.Eager->
                  sig
                    val all : 'a t T.t -> 'T.t t
                    val all_ignore : 'a t T.t -> unit t
                    val sequence : unit t T.t -> unit t
                    val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                    val iter : 'T.t -> f:('-> unit t) -> unit t
                    val fold :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_left :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_right :
                      'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                    val reduce :
                      'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                    val exists : 'T.t -> f:('-> bool t) -> bool t
                    val for_all : 'T.t -> f:('-> bool t) -> bool t
                    val count : 'T.t -> f:('-> bool t) -> int t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> 'a t) -> 'a t
                    val find : 'T.t -> f:('-> bool t) -> 'Option.t t
                    val find_map :
                      'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                    val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                    val filter_map :
                      'T.t -> f:('-> 'Option.t t) -> 'T.t t
                  end
              module Delay :
                functor (T : Collection.Delay->
                  sig
                    val all : 'a t T.t -> 'T.t t
                    val all_ignore : 'a t T.t -> unit t
                    val sequence : unit t T.t -> unit t
                    val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                    val iter : 'T.t -> f:('-> unit t) -> unit t
                    val fold :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_left :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_right :
                      'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                    val reduce :
                      'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                    val exists : 'T.t -> f:('-> bool t) -> bool t
                    val for_all : 'T.t -> f:('-> bool t) -> bool t
                    val count : 'T.t -> f:('-> bool t) -> int t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> 'a t) -> 'a t
                    val find : 'T.t -> f:('-> bool t) -> 'Option.t t
                    val find_map :
                      'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                    val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                    val filter_map :
                      'T.t -> f:('-> 'Option.t t) -> 'T.t t
                  end
            end
          module List :
            sig
              val all : 'a t List.t -> 'List.t t
              val all_ignore : 'a t List.t -> unit t
              val sequence : unit t List.t -> unit t
              val map : 'List.t -> f:('-> 'b t) -> 'List.t t
              val iter : 'List.t -> f:('-> unit t) -> unit t
              val fold : 'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_left :
                'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_right :
                'List.t -> f:('-> '-> 'b t) -> init:'-> 'b t
              val reduce : 'List.t -> f:('-> '-> 'a t) -> 'Option.t t
              val exists : 'List.t -> f:('-> bool t) -> bool t
              val for_all : 'List.t -> f:('-> bool t) -> bool t
              val count : 'List.t -> f:('-> bool t) -> int t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'List.t -> f:('-> 'a t) -> 'a t
              val find : 'List.t -> f:('-> bool t) -> 'Option.t t
              val find_map :
                'List.t -> f:('-> 'Option.t t) -> 'Option.t t
              val filter : 'List.t -> f:('-> bool t) -> 'List.t t
              val filter_map :
                'List.t -> f:('-> 'Option.t t) -> 'List.t t
            end
          module Seq :
            sig
              val all : 'a t Seq.t -> 'Seq.t t
              val all_ignore : 'a t Seq.t -> unit t
              val sequence : unit t Seq.t -> unit t
              val map : 'Seq.t -> f:('-> 'b t) -> 'Seq.t t
              val iter : 'Seq.t -> f:('-> unit t) -> unit t
              val fold : 'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_left :
                'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_right :
                'Seq.t -> f:('-> '-> 'b t) -> init:'-> 'b t
              val reduce : 'Seq.t -> f:('-> '-> 'a t) -> 'Option.t t
              val exists : 'Seq.t -> f:('-> bool t) -> bool t
              val for_all : 'Seq.t -> f:('-> bool t) -> bool t
              val count : 'Seq.t -> f:('-> bool t) -> int t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'Seq.t -> f:('-> 'a t) -> 'a t
              val find : 'Seq.t -> f:('-> bool t) -> 'Option.t t
              val find_map :
                'Seq.t -> f:('-> 'Option.t t) -> 'Option.t t
              val filter : 'Seq.t -> f:('-> bool t) -> 'Seq.t t
              val filter_map :
                'Seq.t -> f:('-> 'Option.t t) -> 'Seq.t t
            end
          val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
          val ( !! ) : '-> 'a t
          val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
          val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
          val ( !$$$ ) :
            ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            'a t -> 'b t -> 'c t -> 'd t -> 'e t
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
          val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
          val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
          module Monad_infix :
            sig
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
            end
          val bind : 'a t -> f:('-> 'b t) -> 'b t
          val return : '-> 'a t
          val map : 'a t -> f:('-> 'b) -> 'b t
          val join : 'a t t -> 'a t
          val ignore_m : 'a t -> unit t
          val all : 'a t list -> 'a list t
          val all_ignore : unit t list -> unit t
          module Let_syntax :
            sig
              val return : '-> 'a t
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              module Let_syntax :
                sig
                  val return : '-> 'a t
                  val bind : 'a t -> f:('-> 'b t) -> 'b t
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val both : 'a t -> 'b t -> ('a * 'b) t
                  module Open_on_rhs : sig  end
                end
            end
          module Syntax :
            sig
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
              val ( !! ) : '-> 'a t
              val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
              val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
            end
        end
      module type S2 =
        sig
          type ('a, 'e) t
          type ('a, 'e) m
          type ('a, 'e) e
          val lift : ('a, 'e) m -> ('a, 'e) t
          val run : ('a, 'e) t -> ('a, 'e) e
          val void : ('a, 'e) t -> (unit, 'e) t
          val sequence : (unit, 'e) t List.t -> (unit, 'e) t
          val forever : ('a, 'e) t -> ('b, 'e) t
          module Fn :
            sig
              val id : '-> ('a, 'e) t
              val ignore : ('a, 'e) t -> (unit, 'e) t
              val nothing : unit -> (unit, 'e) t
              val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
              val apply_n_times :
                n:int -> ('-> ('a, 'e) t) -> '-> ('a, 'e) t
              val compose :
                ('-> ('c, 'e) t) -> ('-> ('b, 'e) t) -> '-> ('c, 'e) t
            end
          module Pair :
            sig
              val fst : ('a * 'b, 'e) t -> ('a, 'e) t
              val snd : ('a * 'b, 'e) t -> ('b, 'e) t
            end
          module Triple :
            sig
              val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
              val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
              val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
            end
          module Lift :
            sig
              val nullary : '-> ('a, 'e) t
              val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val binary :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ternary :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val quaternary :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val quinary :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
            end
          module Exn :
            sig
              val expect :
                ?finally:(unit -> (unit, 's) t) ->
                f:(unit -> ('a, 's) t) ->
                catch:(exn -> ('a, 's) t) -> ('a, 's) t
            end
          module Collection :
            sig
              module type S =
                sig
                  type 'a t
                  val all : ('a, 'e) t t -> ('a t, 'e) t
                  val all_ignore : ('a, 'e) t t -> (unit, 'e) t
                  val sequence : (unit, 'e) t t -> (unit, 'e) t
                  val map : 'a t -> f:('-> ('b, 'e) t) -> ('b t, 'e) t
                  val iter : 'a t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                  val fold :
                    'a t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'a t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'a t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'a t -> f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                  val exists : 'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count : 'a t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'a t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                  val find_map :
                    'a t ->
                    f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                  val filter : 'a t -> f:('-> (bool, 'e) t) -> ('a t, 'e) t
                  val filter_map :
                    'a t -> f:('-> ('Option.t, 'e) t) -> ('b t, 'e) t
                end
              module Eager :
                functor (T : Collection.Eager->
                  sig
                    val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                    val all_ignore : ('a, 'e) t T.t -> (unit, 'e) t
                    val sequence : (unit, 'e) t T.t -> (unit, 'e) t
                    val map :
                      'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                    val iter :
                      'T.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                    val fold :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_left :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_right :
                      'T.t ->
                      f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                    val reduce :
                      'T.t ->
                      f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                    val exists :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val for_all :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val count :
                      'T.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                    val find :
                      'T.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                    val find_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                    val filter :
                      'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                    val filter_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                  end
              module Delay :
                functor (T : Collection.Delay->
                  sig
                    val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                    val all_ignore : ('a, 'e) t T.t -> (unit, 'e) t
                    val sequence : (unit, 'e) t T.t -> (unit, 'e) t
                    val map :
                      'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                    val iter :
                      'T.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                    val fold :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_left :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_right :
                      'T.t ->
                      f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                    val reduce :
                      'T.t ->
                      f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                    val exists :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val for_all :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val count :
                      'T.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                    val find :
                      'T.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                    val find_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                    val filter :
                      'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                    val filter_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                  end
            end
          module List :
            sig
              val all : ('a, 'e) t List.t -> ('List.t, 'e) t
              val all_ignore : ('a, 'e) t List.t -> (unit, 'e) t
              val sequence : (unit, 'e) t List.t -> (unit, 'e) t
              val map :
                'List.t -> f:('-> ('b, 'e) t) -> ('List.t, 'e) t
              val iter : 'List.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
              val fold :
                'List.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_left :
                'List.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_right :
                'List.t ->
                f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
              val reduce :
                'List.t ->
                f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
              val exists :
                'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val for_all :
                'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val count : 'List.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'List.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
              val find :
                'List.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
              val find_map :
                'List.t ->
                f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
              val filter :
                'List.t -> f:('-> (bool, 'e) t) -> ('List.t, 'e) t
              val filter_map :
                'List.t ->
                f:('-> ('Option.t, 'e) t) -> ('List.t, 'e) t
            end
          module Seq :
            sig
              val all : ('a, 'e) t Seq.t -> ('Seq.t, 'e) t
              val all_ignore : ('a, 'e) t Seq.t -> (unit, 'e) t
              val sequence : (unit, 'e) t Seq.t -> (unit, 'e) t
              val map : 'Seq.t -> f:('-> ('b, 'e) t) -> ('Seq.t, 'e) t
              val iter : 'Seq.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
              val fold :
                'Seq.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_left :
                'Seq.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_right :
                'Seq.t ->
                f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
              val reduce :
                'Seq.t -> f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
              val exists : 'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val for_all :
                'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val count : 'Seq.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'Seq.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
              val find :
                'Seq.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
              val find_map :
                'Seq.t ->
                f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
              val filter :
                'Seq.t -> f:('-> (bool, 'e) t) -> ('Seq.t, 'e) t
              val filter_map :
                'Seq.t -> f:('-> ('Option.t, 'e) t) -> ('Seq.t, 'e) t
            end
          val ( >=> ) :
            ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
          val ( !! ) : '-> ('a, 'e) t
          val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
          val ( !$$ ) :
            ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
          val ( !$$$ ) :
            ('-> '-> '-> 'd) ->
            ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            ('a, 's) t ->
            ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            ('a, 's) t ->
            ('b, 's) t ->
            ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
          val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
          val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
          module Let_syntax :
            sig
              val return : '-> ('a, 'b) t
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              module Let_syntax :
                sig
                  val return : '-> ('a, 'b) t
                  val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                  val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                  val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                  module Open_on_rhs : sig  end
                end
            end
          module Monad_infix :
            sig
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
            end
          val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
          val return : '-> ('a, 'b) t
          val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
          val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
          val ignore_m : ('a, 'e) t -> (unit, 'e) t
          val all : ('a, 'e) t list -> ('a list, 'e) t
          val all_ignore : (unit, 'e) t list -> (unit, 'e) t
          module Syntax :
            sig
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              val ( >=> ) :
                ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
              val ( !! ) : '-> ('a, 'e) t
              val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val ( !$$ ) :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
            end
        end
      type 'a thunk
      type 'a t = 'a thunk
      type 'a m = 'a
      type 'a e = 'a
      val lift : '-> 'a t
      val run : 'a t -> 'a
      val void : 'a t -> unit t
      val sequence : unit t List.t -> unit t
      val forever : 'a t -> 'b t
      module Fn :
        sig
          val id : '-> 'a t
          val ignore : 'a t -> unit t
          val nothing : unit -> unit t
          val non : ('-> bool t) -> '-> bool t
          val apply_n_times : n:int -> ('-> 'a t) -> '-> 'a t
          val compose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
        end
      module Pair :
        sig val fst : ('a * 'b) t -> 'a t val snd : ('a * 'b) t -> 'b t end
      module Triple :
        sig
          val fst : ('a * 'b * 'c) t -> 'a t
          val snd : ('a * 'b * 'c) t -> 'b t
          val trd : ('a * 'b * 'c) t -> 'c t
        end
      module Lift :
        sig
          val nullary : '-> 'a t
          val unary : ('-> 'b) -> 'a t -> 'b t
          val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
          val ternary :
            ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
          val quaternary :
            ('-> '-> '-> '-> 'e) ->
            'a t -> 'b t -> 'c t -> 'd t -> 'e t
          val quinary :
            ('-> '-> '-> '-> '-> 'f) ->
            'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
        end
      module Exn :
        sig
          val expect :
            ?finally:(unit -> unit t) ->
            f:(unit -> 'a t) -> catch:(exn -> 'a t) -> 'a t
        end
      module Collection :
        sig
          module type S =
            sig
              type 'a t
              val all : 'a thunk t -> 'a t thunk
              val all_ignore : 'a thunk t -> unit thunk
              val sequence : unit thunk t -> unit thunk
              val map : 'a t -> f:('-> 'b thunk) -> 'b t thunk
              val iter : 'a t -> f:('-> unit thunk) -> unit thunk
              val fold :
                'a t -> init:'-> f:('-> '-> 'b thunk) -> 'b thunk
              val fold_left :
                'a t -> init:'-> f:('-> '-> 'b thunk) -> 'b thunk
              val fold_right :
                'a t -> f:('-> '-> 'b thunk) -> init:'-> 'b thunk
              val reduce :
                'a t -> f:('-> '-> 'a thunk) -> 'Option.t thunk
              val exists : 'a t -> f:('-> bool thunk) -> bool thunk
              val for_all : 'a t -> f:('-> bool thunk) -> bool thunk
              val count : 'a t -> f:('-> bool thunk) -> int thunk
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'b t -> f:('-> 'a thunk) -> 'a thunk
              val find : 'a t -> f:('-> bool thunk) -> 'Option.t thunk
              val find_map :
                'a t -> f:('-> 'Option.t thunk) -> 'Option.t thunk
              val filter : 'a t -> f:('-> bool thunk) -> 'a t thunk
              val filter_map :
                'a t -> f:('-> 'Option.t thunk) -> 'b t thunk
            end
          module Eager :
            functor (T : Collection.Eager->
              sig
                val all : 'a t T.t -> 'T.t t
                val all_ignore : 'a t T.t -> unit t
                val sequence : unit t T.t -> unit t
                val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                val iter : 'T.t -> f:('-> unit t) -> unit t
                val fold : 'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                val fold_left :
                  'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                val fold_right :
                  'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                val reduce : 'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                val exists : 'T.t -> f:('-> bool t) -> bool t
                val for_all : 'T.t -> f:('-> bool t) -> bool t
                val count : 'T.t -> f:('-> bool t) -> int t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'T.t -> f:('-> 'a t) -> 'a t
                val find : 'T.t -> f:('-> bool t) -> 'Option.t t
                val find_map :
                  'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                val filter_map :
                  'T.t -> f:('-> 'Option.t t) -> 'T.t t
              end
          module Delay :
            functor (T : Collection.Delay->
              sig
                val all : 'a t T.t -> 'T.t t
                val all_ignore : 'a t T.t -> unit t
                val sequence : unit t T.t -> unit t
                val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                val iter : 'T.t -> f:('-> unit t) -> unit t
                val fold : 'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                val fold_left :
                  'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                val fold_right :
                  'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                val reduce : 'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                val exists : 'T.t -> f:('-> bool t) -> bool t
                val for_all : 'T.t -> f:('-> bool t) -> bool t
                val count : 'T.t -> f:('-> bool t) -> int t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'T.t -> f:('-> 'a t) -> 'a t
                val find : 'T.t -> f:('-> bool t) -> 'Option.t t
                val find_map :
                  'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                val filter_map :
                  'T.t -> f:('-> 'Option.t t) -> 'T.t t
              end
        end
      module List :
        sig
          val all : 'a t List.t -> 'List.t t
          val all_ignore : 'a t List.t -> unit t
          val sequence : unit t List.t -> unit t
          val map : 'List.t -> f:('-> 'b t) -> 'List.t t
          val iter : 'List.t -> f:('-> unit t) -> unit t
          val fold : 'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
          val fold_left :
            'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
          val fold_right :
            'List.t -> f:('-> '-> 'b t) -> init:'-> 'b t
          val reduce : 'List.t -> f:('-> '-> 'a t) -> 'Option.t t
          val exists : 'List.t -> f:('-> bool t) -> bool t
          val for_all : 'List.t -> f:('-> bool t) -> bool t
          val count : 'List.t -> f:('-> bool t) -> int t
          val map_reduce :
            (module Monoid.S with type t = 'a) ->
            'List.t -> f:('-> 'a t) -> 'a t
          val find : 'List.t -> f:('-> bool t) -> 'Option.t t
          val find_map :
            'List.t -> f:('-> 'Option.t t) -> 'Option.t t
          val filter : 'List.t -> f:('-> bool t) -> 'List.t t
          val filter_map :
            'List.t -> f:('-> 'Option.t t) -> 'List.t t
        end
      module Seq :
        sig
          val all : 'a t Seq.t -> 'Seq.t t
          val all_ignore : 'a t Seq.t -> unit t
          val sequence : unit t Seq.t -> unit t
          val map : 'Seq.t -> f:('-> 'b t) -> 'Seq.t t
          val iter : 'Seq.t -> f:('-> unit t) -> unit t
          val fold : 'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
          val fold_left : 'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
          val fold_right :
            'Seq.t -> f:('-> '-> 'b t) -> init:'-> 'b t
          val reduce : 'Seq.t -> f:('-> '-> 'a t) -> 'Option.t t
          val exists : 'Seq.t -> f:('-> bool t) -> bool t
          val for_all : 'Seq.t -> f:('-> bool t) -> bool t
          val count : 'Seq.t -> f:('-> bool t) -> int t
          val map_reduce :
            (module Monoid.S with type t = 'a) ->
            'Seq.t -> f:('-> 'a t) -> 'a t
          val find : 'Seq.t -> f:('-> bool t) -> 'Option.t t
          val find_map : 'Seq.t -> f:('-> 'Option.t t) -> 'Option.t t
          val filter : 'Seq.t -> f:('-> bool t) -> 'Seq.t t
          val filter_map : 'Seq.t -> f:('-> 'Option.t t) -> 'Seq.t t
        end
      val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
      val ( !! ) : '-> 'a t
      val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
      val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
      val ( !$$$ ) : ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
      val ( !$$$$ ) :
        ('-> '-> '-> '-> 'e) -> 'a t -> 'b t -> 'c t -> 'd t -> 'e t
      val ( !$$$$$ ) :
        ('-> '-> '-> '-> '-> 'f) ->
        'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
      module Monad_infix :
        sig
          val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
          val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
        end
      val bind : 'a t -> f:('-> 'b t) -> 'b t
      val return : '-> 'a t
      val map : 'a t -> f:('-> 'b) -> 'b t
      val join : 'a t t -> 'a t
      val ignore_m : 'a t -> unit t
      val all : 'a t list -> 'a list t
      val all_ignore : unit t list -> unit t
      module Let_syntax :
        sig
          val return : '-> 'a t
          val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
          val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
          module Let_syntax :
            sig
              val return : '-> 'a t
              val bind : 'a t -> f:('-> 'b t) -> 'b t
              val map : 'a t -> f:('-> 'b) -> 'b t
              val both : 'a t -> 'b t -> ('a * 'b) t
              module Open_on_rhs : sig  end
            end
        end
      module Syntax :
        sig
          val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
          val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
          val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
          val ( !! ) : '-> 'a t
          val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
          val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
          val ( !$$$ ) :
            ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            'a t -> 'b t -> 'c t -> 'd t -> 'e t
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
        end
      module T1 :
        functor (M : Monad->
          sig
            type 'a m = 'M.t
            type 'a t =
                'Monads.Std.Monad.Fun.T1.m Monads.Std.Monad.Fun.thunk
            type 'a e = 'Monads.Std.Monad.Fun.T1.m
          end
      module Make :
        functor (M : Monad->
          sig
            val lift : 'M.t -> 'T1(M).t
            val run : 'T1(M).t -> 'Monads.Std.Monad.Fun.T1.m
            val void : 'T1(M).t -> unit T1(M).t
            val sequence : unit T1(M).t list -> unit T1(M).t
            val forever : 'T1(M).t -> 'T1(M).t
            module Fn :
              sig
                val id : '-> 'T1(M).t
                val ignore : 'T1(M).t -> unit T1(M).t
                val nothing : unit -> unit T1(M).t
                val non : ('-> bool T1(M).t) -> '-> bool T1(M).t
                val apply_n_times :
                  n:int -> ('-> 'T1(M).t) -> '-> 'T1(M).t
                val compose :
                  ('-> 'T1(M).t) ->
                  ('-> 'T1(M).t) -> '-> 'T1(M).t
              end
            module Pair :
              sig
                val fst : ('a * 'b) T1(M).t -> 'T1(M).t
                val snd : ('a * 'b) T1(M).t -> 'T1(M).t
              end
            module Triple :
              sig
                val fst : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                val snd : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                val trd : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
              end
            module Lift :
              sig
                val nullary : '-> 'T1(M).t
                val unary : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                val binary :
                  ('-> '-> 'c) -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ternary :
                  ('-> '-> '-> 'd) ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val quaternary :
                  ('-> '-> '-> '-> 'e) ->
                  'T1(M).t ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val quinary :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'T1(M).t ->
                  'T1(M).t ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
              end
            module Exn :
              sig
                val expect :
                  ?finally:(unit -> unit T1(M).t) ->
                  f:(unit -> 'T1(M).t) ->
                  catch:(exn -> 'T1(M).t) -> 'T1(M).t
              end
            module Collection :
              sig
                module type S =
                  sig
                    type 'a t
                    val all : 'T1(M).t t -> 'a t T1(M).t
                    val all_ignore : 'T1(M).t t -> unit T1(M).t
                    val sequence : unit T1(M).t t -> unit T1(M).t
                    val map : 'a t -> f:('-> 'T1(M).t) -> 'b t T1(M).t
                    val iter : 'a t -> f:('-> unit T1(M).t) -> unit T1(M).t
                    val fold :
                      'a t ->
                      init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                    val fold_left :
                      'a t ->
                      init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                    val fold_right :
                      'a t ->
                      f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                    val reduce :
                      'a t ->
                      f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                    val exists :
                      'a t -> f:('-> bool T1(M).t) -> bool T1(M).t
                    val for_all :
                      'a t -> f:('-> bool T1(M).t) -> bool T1(M).t
                    val count : 'a t -> f:('-> bool T1(M).t) -> int T1(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b t -> f:('-> 'T1(M).t) -> 'T1(M).t
                    val find :
                      'a t -> f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                    val find_map :
                      'a t ->
                      f:('-> 'Option.t T1(M).t) -> 'Option.t T1(M).t
                    val filter :
                      'a t -> f:('-> bool T1(M).t) -> 'a t T1(M).t
                    val filter_map :
                      'a t -> f:('-> 'Option.t T1(M).t) -> 'b t T1(M).t
                  end
                module Eager :
                  functor (T : Collection.Eager->
                    sig
                      val all : 'T1(M).t T.t -> 'T.t T1(M).t
                      val all_ignore : 'T1(M).t T.t -> unit T1(M).t
                      val sequence : unit T1(M).t T.t -> unit T1(M).t
                      val map :
                        'T.t -> f:('-> 'T1(M).t) -> 'T.t T1(M).t
                      val iter :
                        'T.t -> f:('-> unit T1(M).t) -> unit T1(M).t
                      val fold :
                        'T.t ->
                        init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                      val fold_left :
                        'T.t ->
                        init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                      val reduce :
                        'T.t ->
                        f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                      val exists :
                        'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                      val for_all :
                        'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                      val count :
                        'T.t -> f:('-> bool T1(M).t) -> int T1(M).t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t -> f:('-> 'T1(M).t) -> 'T1(M).t
                      val find :
                        'T.t ->
                        f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                      val find_map :
                        'T.t ->
                        f:('-> 'Option.t T1(M).t) -> 'Option.t T1(M).t
                      val filter :
                        'T.t -> f:('-> bool T1(M).t) -> 'T.t T1(M).t
                      val filter_map :
                        'T.t ->
                        f:('-> 'Option.t T1(M).t) -> 'T.t T1(M).t
                    end
                module Delay :
                  functor (T : Collection.Delay->
                    sig
                      val all : 'T1(M).t T.t -> 'T.t T1(M).t
                      val all_ignore : 'T1(M).t T.t -> unit T1(M).t
                      val sequence : unit T1(M).t T.t -> unit T1(M).t
                      val map :
                        'T.t -> f:('-> 'T1(M).t) -> 'T.t T1(M).t
                      val iter :
                        'T.t -> f:('-> unit T1(M).t) -> unit T1(M).t
                      val fold :
                        'T.t ->
                        init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                      val fold_left :
                        'T.t ->
                        init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                      val reduce :
                        'T.t ->
                        f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                      val exists :
                        'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                      val for_all :
                        'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                      val count :
                        'T.t -> f:('-> bool T1(M).t) -> int T1(M).t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t -> f:('-> 'T1(M).t) -> 'T1(M).t
                      val find :
                        'T.t ->
                        f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                      val find_map :
                        'T.t ->
                        f:('-> 'Option.t T1(M).t) -> 'Option.t T1(M).t
                      val filter :
                        'T.t -> f:('-> bool T1(M).t) -> 'T.t T1(M).t
                      val filter_map :
                        'T.t ->
                        f:('-> 'Option.t T1(M).t) -> 'T.t T1(M).t
                    end
              end
            module List :
              sig
                val all : 'T1(M).t list -> 'a list T1(M).t
                val all_ignore : 'T1(M).t list -> unit T1(M).t
                val sequence : unit T1(M).t list -> unit T1(M).t
                val map : 'a list -> f:('-> 'T1(M).t) -> 'b list T1(M).t
                val iter : 'a list -> f:('-> unit T1(M).t) -> unit T1(M).t
                val fold :
                  'a list ->
                  init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                val fold_left :
                  'a list ->
                  init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                val fold_right :
                  'a list ->
                  f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                val reduce :
                  'a list ->
                  f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                val exists :
                  'a list -> f:('-> bool T1(M).t) -> bool T1(M).t
                val for_all :
                  'a list -> f:('-> bool T1(M).t) -> bool T1(M).t
                val count : 'a list -> f:('-> bool T1(M).t) -> int T1(M).t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'b list -> f:('-> 'T1(M).t) -> 'T1(M).t
                val find :
                  'a list -> f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                val find_map :
                  'a list ->
                  f:('-> 'Option.t T1(M).t) -> 'Option.t T1(M).t
                val filter :
                  'a list -> f:('-> bool T1(M).t) -> 'a list T1(M).t
                val filter_map :
                  'a list -> f:('-> 'Option.t T1(M).t) -> 'b list T1(M).t
              end
            module Seq :
              sig
                val all :
                  'T1(M).t Core_kernel.Std.Sequence.t ->
                  'Core_kernel.Std.Sequence.t T1(M).t
                val all_ignore :
                  'T1(M).t Core_kernel.Std.Sequence.t -> unit T1(M).t
                val sequence :
                  unit T1(M).t Core_kernel.Std.Sequence.t -> unit T1(M).t
                val map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> 'T1(M).t) ->
                  'Core_kernel.Std.Sequence.t T1(M).t
                val iter :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> unit T1(M).t) -> unit T1(M).t
                val fold :
                  'Core_kernel.Std.Sequence.t ->
                  init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                val fold_left :
                  'Core_kernel.Std.Sequence.t ->
                  init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                val fold_right :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                val reduce :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                val exists :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(M).t) -> bool T1(M).t
                val for_all :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(M).t) -> bool T1(M).t
                val count :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(M).t) -> int T1(M).t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> 'T1(M).t) -> 'T1(M).t
                val find :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                val find_map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> 'Option.t T1(M).t) -> 'Option.t T1(M).t
                val filter :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(M).t) ->
                  'Core_kernel.Std.Sequence.t T1(M).t
                val filter_map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> 'Option.t T1(M).t) ->
                  'Core_kernel.Std.Sequence.t T1(M).t
              end
            val ( >=> ) :
              ('-> 'T1(M).t) -> ('-> 'T1(M).t) -> '-> 'T1(M).t
            val ( !! ) : '-> 'T1(M).t
            val ( !$ ) : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
            val ( !$$ ) :
              ('-> '-> 'c) -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
            val ( !$$$ ) :
              ('-> '-> '-> 'd) ->
              'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
            val ( !$$$$ ) :
              ('-> '-> '-> '-> 'e) ->
              'T1(M).t ->
              'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
            val ( !$$$$$ ) :
              ('-> '-> '-> '-> '-> 'f) ->
              'T1(M).t ->
              'T1(M).t ->
              'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
            val ( >>= ) : 'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
            val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
            module Monad_infix :
              sig
                val ( >>= ) : 'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
              end
            val bind : 'T1(M).t -> f:('-> 'T1(M).t) -> 'T1(M).t
            val return : '-> 'T1(M).t
            val map : 'T1(M).t -> f:('-> 'b) -> 'T1(M).t
            val join : 'T1(M).t T1(M).t -> 'T1(M).t
            val ignore_m : 'T1(M).t -> unit T1(M).t
            val all : 'T1(M).t list -> 'a list T1(M).t
            val all_ignore : unit T1(M).t list -> unit T1(M).t
            module Let_syntax :
              sig
                val return : '-> 'T1(M).t
                val ( >>= ) : 'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                module Let_syntax :
                  sig
                    val return : '-> 'T1(M).t
                    val bind :
                      'T1(M).t -> f:('-> 'T1(M).t) -> 'T1(M).t
                    val map : 'T1(M).t -> f:('-> 'b) -> 'T1(M).t
                    val both : 'T1(M).t -> 'T1(M).t -> ('a * 'b) T1(M).t
                    module Open_on_rhs : sig  end
                  end
              end
            module Syntax :
              sig
                val ( >>= ) : 'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                val ( >=> ) :
                  ('-> 'T1(M).t) ->
                  ('-> 'T1(M).t) -> '-> 'T1(M).t
                val ( !! ) : '-> 'T1(M).t
                val ( !$ ) : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  'T1(M).t ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'T1(M).t ->
                  'T1(M).t ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
              end
          end
      module T2 :
        functor (M : Monad2->
          sig
            type ('a, 'e) m = ('a, 'e) M.t
            type ('a, 'e) t =
                ('a, 'e) Monads.Std.Monad.Fun.T2.m Monads.Std.Monad.Fun.thunk
            type ('a, 'e) e = ('a, 'e) Monads.Std.Monad.Fun.T2.m
          end
      module Make2 :
        functor (M : Monad2->
          sig
            val lift : ('a, 'e) M.t -> ('a, 'e) T2(M).t
            val run : ('a, 'e) T2(M).t -> ('a, 'e) Monads.Std.Monad.Fun.T2.m
            val void : ('a, 'e) T2(M).t -> (unit, 'e) T2(M).t
            val sequence : (unit, 'e) T2(M).t list -> (unit, 'e) T2(M).t
            val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
            module Fn :
              sig
                val id : '-> ('a, 'e) T2(M).t
                val ignore : ('a, 'e) T2(M).t -> (unit, 'e) T2(M).t
                val nothing : unit -> (unit, 'e) T2(M).t
                val non :
                  ('-> (bool, 'e) T2(M).t) -> '-> (bool, 'e) T2(M).t
                val apply_n_times :
                  n:int -> ('-> ('a, 'e) T2(M).t) -> '-> ('a, 'e) T2(M).t
                val compose :
                  ('-> ('c, 'e) T2(M).t) ->
                  ('-> ('b, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
              end
            module Pair :
              sig
                val fst : ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
                val snd : ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
              end
            module Triple :
              sig
                val fst : ('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
                val snd : ('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
                val trd : ('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
              end
            module Lift :
              sig
                val nullary : '-> ('a, 'e) T2(M).t
                val unary :
                  ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                val binary :
                  ('-> '-> 'c) ->
                  ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                val ternary :
                  ('-> '-> '-> 'd) ->
                  ('a, 'e) T2(M).t ->
                  ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                val quaternary :
                  ('-> '-> '-> '-> 'e) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t -> ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                val quinary :
                  ('-> '-> '-> '-> '-> 'f) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t ->
                  ('d, 's) T2(M).t -> ('e, 's) T2(M).t -> ('f, 's) T2(M).t
              end
            module Exn :
              sig
                val expect :
                  ?finally:(unit -> (unit, 's) T2(M).t) ->
                  f:(unit -> ('a, 's) T2(M).t) ->
                  catch:(exn -> ('a, 's) T2(M).t) -> ('a, 's) T2(M).t
              end
            module Collection :
              sig
                module type S =
                  sig
                    type 'a t
                    val all : ('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
                    val all_ignore : ('a, 'e) T2(M).t t -> (unit, 'e) T2(M).t
                    val sequence : (unit, 'e) T2(M).t t -> (unit, 'e) T2(M).t
                    val map :
                      'a t ->
                      f:('-> ('b, 'e) T2(M).t) -> ('b t, 'e) T2(M).t
                    val iter :
                      'a t ->
                      f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                    val fold :
                      'a t ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_left :
                      'a t ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_right :
                      'a t ->
                      f:('-> '-> ('b, 'e) T2(M).t) ->
                      init:'-> ('b, 'e) T2(M).t
                    val reduce :
                      'a t ->
                      f:('-> '-> ('a, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val exists :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val for_all :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val count :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b t -> f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                    val find :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val find_map :
                      'a t ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val filter :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) -> ('a t, 'e) T2(M).t
                    val filter_map :
                      'a t ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('b t, 'e) T2(M).t
                  end
                module Eager :
                  functor (T : Collection.Eager->
                    sig
                      val all : ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                      val all_ignore :
                        ('a, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                      val sequence :
                        (unit, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                      val map :
                        'T.t ->
                        f:('-> ('b, 'e) T2(M).t) -> ('T.t, 'e) T2(M).t
                      val iter :
                        'T.t ->
                        f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                      val fold :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                      val fold_left :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> ('b, 'e) T2(M).t) ->
                        init:'-> ('b, 'e) T2(M).t
                      val reduce :
                        'T.t ->
                        f:('-> '-> ('a, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val exists :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                      val for_all :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                      val count :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t ->
                        f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                      val find :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val find_map :
                        'T.t ->
                        f:('-> ('Option.t, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val filter :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> ('T.t, 'e) T2(M).t
                      val filter_map :
                        'T.t ->
                        f:('-> ('Option.t, 'e) T2(M).t) ->
                        ('T.t, 'e) T2(M).t
                    end
                module Delay :
                  functor (T : Collection.Delay->
                    sig
                      val all : ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                      val all_ignore :
                        ('a, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                      val sequence :
                        (unit, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                      val map :
                        'T.t ->
                        f:('-> ('b, 'e) T2(M).t) -> ('T.t, 'e) T2(M).t
                      val iter :
                        'T.t ->
                        f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                      val fold :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                      val fold_left :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> ('b, 'e) T2(M).t) ->
                        init:'-> ('b, 'e) T2(M).t
                      val reduce :
                        'T.t ->
                        f:('-> '-> ('a, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val exists :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                      val for_all :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                      val count :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t ->
                        f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                      val find :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val find_map :
                        'T.t ->
                        f:('-> ('Option.t, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val filter :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> ('T.t, 'e) T2(M).t
                      val filter_map :
                        'T.t ->
                        f:('-> ('Option.t, 'e) T2(M).t) ->
                        ('T.t, 'e) T2(M).t
                    end
              end
            module List :
              sig
                val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                val all_ignore : ('a, 'e) T2(M).t list -> (unit, 'e) T2(M).t
                val sequence : (unit, 'e) T2(M).t list -> (unit, 'e) T2(M).t
                val map :
                  'a list ->
                  f:('-> ('b, 'e) T2(M).t) -> ('b list, 'e) T2(M).t
                val iter :
                  'a list ->
                  f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                val fold :
                  'a list ->
                  init:'->
                  f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val fold_left :
                  'a list ->
                  init:'->
                  f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val fold_right :
                  'a list ->
                  f:('-> '-> ('b, 'e) T2(M).t) ->
                  init:'-> ('b, 'e) T2(M).t
                val reduce :
                  'a list ->
                  f:('-> '-> ('a, 'e) T2(M).t) ->
                  ('Option.t, 'e) T2(M).t
                val exists :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                val for_all :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                val count :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'b list -> f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                val find :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> ('Option.t, 'e) T2(M).t
                val find_map :
                  'a list ->
                  f:('-> ('Option.t, 'e) T2(M).t) ->
                  ('Option.t, 'e) T2(M).t
                val filter :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> ('a list, 'e) T2(M).t
                val filter_map :
                  'a list ->
                  f:('-> ('Option.t, 'e) T2(M).t) ->
                  ('b list, 'e) T2(M).t
              end
            module Seq :
              sig
                val all :
                  ('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                  ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                val all_ignore :
                  ('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                  (unit, 'e) T2(M).t
                val sequence :
                  (unit, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                  (unit, 'e) T2(M).t
                val map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> ('b, 'e) T2(M).t) ->
                  ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                val iter :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                val fold :
                  'Core_kernel.Std.Sequence.t ->
                  init:'->
                  f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val fold_left :
                  'Core_kernel.Std.Sequence.t ->
                  init:'->
                  f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val fold_right :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> '-> ('b, 'e) T2(M).t) ->
                  init:'-> ('b, 'e) T2(M).t
                val reduce :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> '-> ('a, 'e) T2(M).t) ->
                  ('Option.t, 'e) T2(M).t
                val exists :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                val for_all :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                val count :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                val find :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) -> ('Option.t, 'e) T2(M).t
                val find_map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> ('Option.t, 'e) T2(M).t) ->
                  ('Option.t, 'e) T2(M).t
                val filter :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) ->
                  ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                val filter_map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> ('Option.t, 'e) T2(M).t) ->
                  ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
              end
            val ( >=> ) :
              ('-> ('b, 'e) T2(M).t) ->
              ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
            val ( !! ) : '-> ('a, 'e) T2(M).t
            val ( !$ ) : ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
            val ( !$$ ) :
              ('-> '-> 'c) ->
              ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
            val ( !$$$ ) :
              ('-> '-> '-> 'd) ->
              ('a, 'e) T2(M).t ->
              ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
            val ( !$$$$ ) :
              ('-> '-> '-> '-> 'e) ->
              ('a, 's) T2(M).t ->
              ('b, 's) T2(M).t ->
              ('c, 's) T2(M).t -> ('d, 's) T2(M).t -> ('e, 's) T2(M).t
            val ( !$$$$$ ) :
              ('-> '-> '-> '-> '-> 'f) ->
              ('a, 's) T2(M).t ->
              ('b, 's) T2(M).t ->
              ('c, 's) T2(M).t ->
              ('d, 's) T2(M).t -> ('e, 's) T2(M).t -> ('f, 's) T2(M).t
            val ( >>= ) :
              ('a, 'e) T2(M).t ->
              ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
            val ( >>| ) : ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
            module Let_syntax :
              sig
                val return : '-> ('a, 'b) T2(M).t
                val ( >>= ) :
                  ('a, 'e) T2(M).t ->
                  ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val ( >>| ) :
                  ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                module Let_syntax :
                  sig
                    val return : '-> ('a, 'b) T2(M).t
                    val bind :
                      ('a, 'e) T2(M).t ->
                      f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val map :
                      ('a, 'e) T2(M).t -> f:('-> 'b) -> ('b, 'e) T2(M).t
                    val both :
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
                    module Open_on_rhs : sig  end
                  end
              end
            module Monad_infix :
              sig
                val ( >>= ) :
                  ('a, 'e) T2(M).t ->
                  ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val ( >>| ) :
                  ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
              end
            val bind :
              ('a, 'e) T2(M).t ->
              f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
            val return : '-> ('a, 'b) T2(M).t
            val map : ('a, 'e) T2(M).t -> f:('-> 'b) -> ('b, 'e) T2(M).t
            val join : (('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
            val ignore_m : ('a, 'e) T2(M).t -> (unit, 'e) T2(M).t
            val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
            val all_ignore : (unit, 'e) T2(M).t list -> (unit, 'e) T2(M).t
            module Syntax :
              sig
                val ( >>= ) :
                  ('a, 'e) T2(M).t ->
                  ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val ( >>| ) :
                  ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                val ( >=> ) :
                  ('-> ('b, 'e) T2(M).t) ->
                  ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                val ( !! ) : '-> ('a, 'e) T2(M).t
                val ( !$ ) :
                  ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) ->
                  ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  ('a, 'e) T2(M).t ->
                  ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t -> ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t ->
                  ('d, 's) T2(M).t -> ('e, 's) T2(M).t -> ('f, 's) T2(M).t
              end
          end
    end
  module Lazy :
    sig
      module type S =
        sig
          type 'a t
          type 'a m
          type 'a e
          val lift : 'a m -> 'a t
          val run : 'a t -> 'a e
          val void : 'a t -> unit t
          val sequence : unit t List.t -> unit t
          val forever : 'a t -> 'b t
          module Fn :
            sig
              val id : '-> 'a t
              val ignore : 'a t -> unit t
              val nothing : unit -> unit t
              val non : ('-> bool t) -> '-> bool t
              val apply_n_times : n:int -> ('-> 'a t) -> '-> 'a t
              val compose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
            end
          module Pair :
            sig
              val fst : ('a * 'b) t -> 'a t
              val snd : ('a * 'b) t -> 'b t
            end
          module Triple :
            sig
              val fst : ('a * 'b * 'c) t -> 'a t
              val snd : ('a * 'b * 'c) t -> 'b t
              val trd : ('a * 'b * 'c) t -> 'c t
            end
          module Lift :
            sig
              val nullary : '-> 'a t
              val unary : ('-> 'b) -> 'a t -> 'b t
              val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ternary :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val quaternary :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val quinary :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
            end
          module Exn :
            sig
              val expect :
                ?finally:(unit -> unit t) ->
                f:(unit -> 'a t) -> catch:(exn -> 'a t) -> 'a t
            end
          module Collection :
            sig
              module type S =
                sig
                  type 'a t
                  val all : 'a t t -> 'a t t
                  val all_ignore : 'a t t -> unit t
                  val sequence : unit t t -> unit t
                  val map : 'a t -> f:('-> 'b t) -> 'b t t
                  val iter : 'a t -> f:('-> unit t) -> unit t
                  val fold : 'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce : 'a t -> f:('-> '-> 'a t) -> 'Option.t t
                  val exists : 'a t -> f:('-> bool t) -> bool t
                  val for_all : 'a t -> f:('-> bool t) -> bool t
                  val count : 'a t -> f:('-> bool t) -> int t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b t -> f:('-> 'a t) -> 'a t
                  val find : 'a t -> f:('-> bool t) -> 'Option.t t
                  val find_map :
                    'a t -> f:('-> 'Option.t t) -> 'Option.t t
                  val filter : 'a t -> f:('-> bool t) -> 'a t t
                  val filter_map : 'a t -> f:('-> 'Option.t t) -> 'b t t
                end
              module Eager :
                functor (T : Collection.Eager->
                  sig
                    val all : 'a t T.t -> 'T.t t
                    val all_ignore : 'a t T.t -> unit t
                    val sequence : unit t T.t -> unit t
                    val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                    val iter : 'T.t -> f:('-> unit t) -> unit t
                    val fold :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_left :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_right :
                      'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                    val reduce :
                      'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                    val exists : 'T.t -> f:('-> bool t) -> bool t
                    val for_all : 'T.t -> f:('-> bool t) -> bool t
                    val count : 'T.t -> f:('-> bool t) -> int t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> 'a t) -> 'a t
                    val find : 'T.t -> f:('-> bool t) -> 'Option.t t
                    val find_map :
                      'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                    val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                    val filter_map :
                      'T.t -> f:('-> 'Option.t t) -> 'T.t t
                  end
              module Delay :
                functor (T : Collection.Delay->
                  sig
                    val all : 'a t T.t -> 'T.t t
                    val all_ignore : 'a t T.t -> unit t
                    val sequence : unit t T.t -> unit t
                    val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                    val iter : 'T.t -> f:('-> unit t) -> unit t
                    val fold :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_left :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_right :
                      'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                    val reduce :
                      'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                    val exists : 'T.t -> f:('-> bool t) -> bool t
                    val for_all : 'T.t -> f:('-> bool t) -> bool t
                    val count : 'T.t -> f:('-> bool t) -> int t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> 'a t) -> 'a t
                    val find : 'T.t -> f:('-> bool t) -> 'Option.t t
                    val find_map :
                      'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                    val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                    val filter_map :
                      'T.t -> f:('-> 'Option.t t) -> 'T.t t
                  end
            end
          module List :
            sig
              val all : 'a t List.t -> 'List.t t
              val all_ignore : 'a t List.t -> unit t
              val sequence : unit t List.t -> unit t
              val map : 'List.t -> f:('-> 'b t) -> 'List.t t
              val iter : 'List.t -> f:('-> unit t) -> unit t
              val fold : 'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_left :
                'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_right :
                'List.t -> f:('-> '-> 'b t) -> init:'-> 'b t
              val reduce : 'List.t -> f:('-> '-> 'a t) -> 'Option.t t
              val exists : 'List.t -> f:('-> bool t) -> bool t
              val for_all : 'List.t -> f:('-> bool t) -> bool t
              val count : 'List.t -> f:('-> bool t) -> int t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'List.t -> f:('-> 'a t) -> 'a t
              val find : 'List.t -> f:('-> bool t) -> 'Option.t t
              val find_map :
                'List.t -> f:('-> 'Option.t t) -> 'Option.t t
              val filter : 'List.t -> f:('-> bool t) -> 'List.t t
              val filter_map :
                'List.t -> f:('-> 'Option.t t) -> 'List.t t
            end
          module Seq :
            sig
              val all : 'a t Seq.t -> 'Seq.t t
              val all_ignore : 'a t Seq.t -> unit t
              val sequence : unit t Seq.t -> unit t
              val map : 'Seq.t -> f:('-> 'b t) -> 'Seq.t t
              val iter : 'Seq.t -> f:('-> unit t) -> unit t
              val fold : 'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_left :
                'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_right :
                'Seq.t -> f:('-> '-> 'b t) -> init:'-> 'b t
              val reduce : 'Seq.t -> f:('-> '-> 'a t) -> 'Option.t t
              val exists : 'Seq.t -> f:('-> bool t) -> bool t
              val for_all : 'Seq.t -> f:('-> bool t) -> bool t
              val count : 'Seq.t -> f:('-> bool t) -> int t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'Seq.t -> f:('-> 'a t) -> 'a t
              val find : 'Seq.t -> f:('-> bool t) -> 'Option.t t
              val find_map :
                'Seq.t -> f:('-> 'Option.t t) -> 'Option.t t
              val filter : 'Seq.t -> f:('-> bool t) -> 'Seq.t t
              val filter_map :
                'Seq.t -> f:('-> 'Option.t t) -> 'Seq.t t
            end
          val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
          val ( !! ) : '-> 'a t
          val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
          val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
          val ( !$$$ ) :
            ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            'a t -> 'b t -> 'c t -> 'd t -> 'e t
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
          val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
          val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
          module Monad_infix :
            sig
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
            end
          val bind : 'a t -> f:('-> 'b t) -> 'b t
          val return : '-> 'a t
          val map : 'a t -> f:('-> 'b) -> 'b t
          val join : 'a t t -> 'a t
          val ignore_m : 'a t -> unit t
          val all : 'a t list -> 'a list t
          val all_ignore : unit t list -> unit t
          module Let_syntax :
            sig
              val return : '-> 'a t
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              module Let_syntax :
                sig
                  val return : '-> 'a t
                  val bind : 'a t -> f:('-> 'b t) -> 'b t
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val both : 'a t -> 'b t -> ('a * 'b) t
                  module Open_on_rhs : sig  end
                end
            end
          module Syntax :
            sig
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
              val ( !! ) : '-> 'a t
              val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
              val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
            end
        end
      module type S2 =
        sig
          type ('a, 'e) t
          type ('a, 'e) m
          type ('a, 'e) e
          val lift : ('a, 'e) m -> ('a, 'e) t
          val run : ('a, 'e) t -> ('a, 'e) e
          val void : ('a, 'e) t -> (unit, 'e) t
          val sequence : (unit, 'e) t List.t -> (unit, 'e) t
          val forever : ('a, 'e) t -> ('b, 'e) t
          module Fn :
            sig
              val id : '-> ('a, 'e) t
              val ignore : ('a, 'e) t -> (unit, 'e) t
              val nothing : unit -> (unit, 'e) t
              val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
              val apply_n_times :
                n:int -> ('-> ('a, 'e) t) -> '-> ('a, 'e) t
              val compose :
                ('-> ('c, 'e) t) -> ('-> ('b, 'e) t) -> '-> ('c, 'e) t
            end
          module Pair :
            sig
              val fst : ('a * 'b, 'e) t -> ('a, 'e) t
              val snd : ('a * 'b, 'e) t -> ('b, 'e) t
            end
          module Triple :
            sig
              val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
              val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
              val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
            end
          module Lift :
            sig
              val nullary : '-> ('a, 'e) t
              val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val binary :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ternary :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val quaternary :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val quinary :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
            end
          module Exn :
            sig
              val expect :
                ?finally:(unit -> (unit, 's) t) ->
                f:(unit -> ('a, 's) t) ->
                catch:(exn -> ('a, 's) t) -> ('a, 's) t
            end
          module Collection :
            sig
              module type S =
                sig
                  type 'a t
                  val all : ('a, 'e) t t -> ('a t, 'e) t
                  val all_ignore : ('a, 'e) t t -> (unit, 'e) t
                  val sequence : (unit, 'e) t t -> (unit, 'e) t
                  val map : 'a t -> f:('-> ('b, 'e) t) -> ('b t, 'e) t
                  val iter : 'a t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                  val fold :
                    'a t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'a t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'a t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'a t -> f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                  val exists : 'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count : 'a t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'a t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                  val find_map :
                    'a t ->
                    f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                  val filter : 'a t -> f:('-> (bool, 'e) t) -> ('a t, 'e) t
                  val filter_map :
                    'a t -> f:('-> ('Option.t, 'e) t) -> ('b t, 'e) t
                end
              module Eager :
                functor (T : Collection.Eager->
                  sig
                    val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                    val all_ignore : ('a, 'e) t T.t -> (unit, 'e) t
                    val sequence : (unit, 'e) t T.t -> (unit, 'e) t
                    val map :
                      'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                    val iter :
                      'T.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                    val fold :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_left :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_right :
                      'T.t ->
                      f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                    val reduce :
                      'T.t ->
                      f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                    val exists :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val for_all :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val count :
                      'T.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                    val find :
                      'T.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                    val find_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                    val filter :
                      'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                    val filter_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                  end
              module Delay :
                functor (T : Collection.Delay->
                  sig
                    val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                    val all_ignore : ('a, 'e) t T.t -> (unit, 'e) t
                    val sequence : (unit, 'e) t T.t -> (unit, 'e) t
                    val map :
                      'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                    val iter :
                      'T.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                    val fold :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_left :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_right :
                      'T.t ->
                      f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                    val reduce :
                      'T.t ->
                      f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                    val exists :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val for_all :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val count :
                      'T.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                    val find :
                      'T.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                    val find_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                    val filter :
                      'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                    val filter_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                  end
            end
          module List :
            sig
              val all : ('a, 'e) t List.t -> ('List.t, 'e) t
              val all_ignore : ('a, 'e) t List.t -> (unit, 'e) t
              val sequence : (unit, 'e) t List.t -> (unit, 'e) t
              val map :
                'List.t -> f:('-> ('b, 'e) t) -> ('List.t, 'e) t
              val iter : 'List.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
              val fold :
                'List.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_left :
                'List.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_right :
                'List.t ->
                f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
              val reduce :
                'List.t ->
                f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
              val exists :
                'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val for_all :
                'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val count : 'List.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'List.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
              val find :
                'List.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
              val find_map :
                'List.t ->
                f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
              val filter :
                'List.t -> f:('-> (bool, 'e) t) -> ('List.t, 'e) t
              val filter_map :
                'List.t ->
                f:('-> ('Option.t, 'e) t) -> ('List.t, 'e) t
            end
          module Seq :
            sig
              val all : ('a, 'e) t Seq.t -> ('Seq.t, 'e) t
              val all_ignore : ('a, 'e) t Seq.t -> (unit, 'e) t
              val sequence : (unit, 'e) t Seq.t -> (unit, 'e) t
              val map : 'Seq.t -> f:('-> ('b, 'e) t) -> ('Seq.t, 'e) t
              val iter : 'Seq.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
              val fold :
                'Seq.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_left :
                'Seq.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_right :
                'Seq.t ->
                f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
              val reduce :
                'Seq.t -> f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
              val exists : 'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val for_all :
                'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val count : 'Seq.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'Seq.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
              val find :
                'Seq.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
              val find_map :
                'Seq.t ->
                f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
              val filter :
                'Seq.t -> f:('-> (bool, 'e) t) -> ('Seq.t, 'e) t
              val filter_map :
                'Seq.t -> f:('-> ('Option.t, 'e) t) -> ('Seq.t, 'e) t
            end
          val ( >=> ) :
            ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
          val ( !! ) : '-> ('a, 'e) t
          val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
          val ( !$$ ) :
            ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
          val ( !$$$ ) :
            ('-> '-> '-> 'd) ->
            ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            ('a, 's) t ->
            ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            ('a, 's) t ->
            ('b, 's) t ->
            ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
          val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
          val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
          module Let_syntax :
            sig
              val return : '-> ('a, 'b) t
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              module Let_syntax :
                sig
                  val return : '-> ('a, 'b) t
                  val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                  val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                  val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                  module Open_on_rhs : sig  end
                end
            end
          module Monad_infix :
            sig
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
            end
          val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
          val return : '-> ('a, 'b) t
          val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
          val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
          val ignore_m : ('a, 'e) t -> (unit, 'e) t
          val all : ('a, 'e) t list -> ('a list, 'e) t
          val all_ignore : (unit, 'e) t list -> (unit, 'e) t
          module Syntax :
            sig
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              val ( >=> ) :
                ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
              val ( !! ) : '-> ('a, 'e) t
              val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val ( !$$ ) :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
            end
        end
      type 'a t = 'Core_kernel.Std.Lazy.t
      type 'a m = 'a
      type 'a e = 'a
      val lift : '-> 'a t
      val run : 'a t -> 'a
      val void : 'a t -> unit t
      val sequence : unit t List.t -> unit t
      val forever : 'a t -> 'b t
      module Fn :
        sig
          val id : '-> 'a t
          val ignore : 'a t -> unit t
          val nothing : unit -> unit t
          val non : ('-> bool t) -> '-> bool t
          val apply_n_times : n:int -> ('-> 'a t) -> '-> 'a t
          val compose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
        end
      module Pair :
        sig val fst : ('a * 'b) t -> 'a t val snd : ('a * 'b) t -> 'b t end
      module Triple :
        sig
          val fst : ('a * 'b * 'c) t -> 'a t
          val snd : ('a * 'b * 'c) t -> 'b t
          val trd : ('a * 'b * 'c) t -> 'c t
        end
      module Lift :
        sig
          val nullary : '-> 'a t
          val unary : ('-> 'b) -> 'a t -> 'b t
          val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
          val ternary :
            ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
          val quaternary :
            ('-> '-> '-> '-> 'e) ->
            'a t -> 'b t -> 'c t -> 'd t -> 'e t
          val quinary :
            ('-> '-> '-> '-> '-> 'f) ->
            'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
        end
      module Exn :
        sig
          val expect :
            ?finally:(unit -> unit t) ->
            f:(unit -> 'a t) -> catch:(exn -> 'a t) -> 'a t
        end
      module Collection :
        sig
          module type S =
            sig
              type 'a t
              val all :
                'Core_kernel.Std.Lazy.t t -> 'a t Core_kernel.Std.Lazy.t
              val all_ignore :
                'Core_kernel.Std.Lazy.t t -> unit Core_kernel.Std.Lazy.t
              val sequence :
                unit Core_kernel.Std.Lazy.t t -> unit Core_kernel.Std.Lazy.t
              val map :
                'a t ->
                f:('-> 'Core_kernel.Std.Lazy.t) ->
                'b t Core_kernel.Std.Lazy.t
              val iter :
                'a t ->
                f:('-> unit Core_kernel.Std.Lazy.t) ->
                unit Core_kernel.Std.Lazy.t
              val fold :
                'a t ->
                init:'->
                f:('-> '-> 'Core_kernel.Std.Lazy.t) ->
                'Core_kernel.Std.Lazy.t
              val fold_left :
                'a t ->
                init:'->
                f:('-> '-> 'Core_kernel.Std.Lazy.t) ->
                'Core_kernel.Std.Lazy.t
              val fold_right :
                'a t ->
                f:('-> '-> 'Core_kernel.Std.Lazy.t) ->
                init:'-> 'Core_kernel.Std.Lazy.t
              val reduce :
                'a t ->
                f:('-> '-> 'Core_kernel.Std.Lazy.t) ->
                'Option.t Core_kernel.Std.Lazy.t
              val exists :
                'a t ->
                f:('-> bool Core_kernel.Std.Lazy.t) ->
                bool Core_kernel.Std.Lazy.t
              val for_all :
                'a t ->
                f:('-> bool Core_kernel.Std.Lazy.t) ->
                bool Core_kernel.Std.Lazy.t
              val count :
                'a t ->
                f:('-> bool Core_kernel.Std.Lazy.t) ->
                int Core_kernel.Std.Lazy.t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'b t ->
                f:('-> 'Core_kernel.Std.Lazy.t) ->
                'Core_kernel.Std.Lazy.t
              val find :
                'a t ->
                f:('-> bool Core_kernel.Std.Lazy.t) ->
                'Option.t Core_kernel.Std.Lazy.t
              val find_map :
                'a t ->
                f:('-> 'Option.t Core_kernel.Std.Lazy.t) ->
                'Option.t Core_kernel.Std.Lazy.t
              val filter :
                'a t ->
                f:('-> bool Core_kernel.Std.Lazy.t) ->
                'a t Core_kernel.Std.Lazy.t
              val filter_map :
                'a t ->
                f:('-> 'Option.t Core_kernel.Std.Lazy.t) ->
                'b t Core_kernel.Std.Lazy.t
            end
          module Eager :
            functor (T : Collection.Eager->
              sig
                val all : 'a t T.t -> 'T.t t
                val all_ignore : 'a t T.t -> unit t
                val sequence : unit t T.t -> unit t
                val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                val iter : 'T.t -> f:('-> unit t) -> unit t
                val fold : 'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                val fold_left :
                  'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                val fold_right :
                  'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                val reduce : 'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                val exists : 'T.t -> f:('-> bool t) -> bool t
                val for_all : 'T.t -> f:('-> bool t) -> bool t
                val count : 'T.t -> f:('-> bool t) -> int t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'T.t -> f:('-> 'a t) -> 'a t
                val find : 'T.t -> f:('-> bool t) -> 'Option.t t
                val find_map :
                  'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                val filter_map :
                  'T.t -> f:('-> 'Option.t t) -> 'T.t t
              end
          module Delay :
            functor (T : Collection.Delay->
              sig
                val all : 'a t T.t -> 'T.t t
                val all_ignore : 'a t T.t -> unit t
                val sequence : unit t T.t -> unit t
                val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                val iter : 'T.t -> f:('-> unit t) -> unit t
                val fold : 'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                val fold_left :
                  'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                val fold_right :
                  'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                val reduce : 'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                val exists : 'T.t -> f:('-> bool t) -> bool t
                val for_all : 'T.t -> f:('-> bool t) -> bool t
                val count : 'T.t -> f:('-> bool t) -> int t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'T.t -> f:('-> 'a t) -> 'a t
                val find : 'T.t -> f:('-> bool t) -> 'Option.t t
                val find_map :
                  'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                val filter_map :
                  'T.t -> f:('-> 'Option.t t) -> 'T.t t
              end
        end
      module List :
        sig
          val all : 'a t List.t -> 'List.t t
          val all_ignore : 'a t List.t -> unit t
          val sequence : unit t List.t -> unit t
          val map : 'List.t -> f:('-> 'b t) -> 'List.t t
          val iter : 'List.t -> f:('-> unit t) -> unit t
          val fold : 'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
          val fold_left :
            'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
          val fold_right :
            'List.t -> f:('-> '-> 'b t) -> init:'-> 'b t
          val reduce : 'List.t -> f:('-> '-> 'a t) -> 'Option.t t
          val exists : 'List.t -> f:('-> bool t) -> bool t
          val for_all : 'List.t -> f:('-> bool t) -> bool t
          val count : 'List.t -> f:('-> bool t) -> int t
          val map_reduce :
            (module Monoid.S with type t = 'a) ->
            'List.t -> f:('-> 'a t) -> 'a t
          val find : 'List.t -> f:('-> bool t) -> 'Option.t t
          val find_map :
            'List.t -> f:('-> 'Option.t t) -> 'Option.t t
          val filter : 'List.t -> f:('-> bool t) -> 'List.t t
          val filter_map :
            'List.t -> f:('-> 'Option.t t) -> 'List.t t
        end
      module Seq :
        sig
          val all : 'a t Seq.t -> 'Seq.t t
          val all_ignore : 'a t Seq.t -> unit t
          val sequence : unit t Seq.t -> unit t
          val map : 'Seq.t -> f:('-> 'b t) -> 'Seq.t t
          val iter : 'Seq.t -> f:('-> unit t) -> unit t
          val fold : 'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
          val fold_left : 'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
          val fold_right :
            'Seq.t -> f:('-> '-> 'b t) -> init:'-> 'b t
          val reduce : 'Seq.t -> f:('-> '-> 'a t) -> 'Option.t t
          val exists : 'Seq.t -> f:('-> bool t) -> bool t
          val for_all : 'Seq.t -> f:('-> bool t) -> bool t
          val count : 'Seq.t -> f:('-> bool t) -> int t
          val map_reduce :
            (module Monoid.S with type t = 'a) ->
            'Seq.t -> f:('-> 'a t) -> 'a t
          val find : 'Seq.t -> f:('-> bool t) -> 'Option.t t
          val find_map : 'Seq.t -> f:('-> 'Option.t t) -> 'Option.t t
          val filter : 'Seq.t -> f:('-> bool t) -> 'Seq.t t
          val filter_map : 'Seq.t -> f:('-> 'Option.t t) -> 'Seq.t t
        end
      val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
      val ( !! ) : '-> 'a t
      val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
      val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
      val ( !$$$ ) : ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
      val ( !$$$$ ) :
        ('-> '-> '-> '-> 'e) -> 'a t -> 'b t -> 'c t -> 'd t -> 'e t
      val ( !$$$$$ ) :
        ('-> '-> '-> '-> '-> 'f) ->
        'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
      module Monad_infix :
        sig
          val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
          val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
        end
      val bind : 'a t -> f:('-> 'b t) -> 'b t
      val return : '-> 'a t
      val map : 'a t -> f:('-> 'b) -> 'b t
      val join : 'a t t -> 'a t
      val ignore_m : 'a t -> unit t
      val all : 'a t list -> 'a list t
      val all_ignore : unit t list -> unit t
      module Let_syntax :
        sig
          val return : '-> 'a t
          val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
          val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
          module Let_syntax :
            sig
              val return : '-> 'a t
              val bind : 'a t -> f:('-> 'b t) -> 'b t
              val map : 'a t -> f:('-> 'b) -> 'b t
              val both : 'a t -> 'b t -> ('a * 'b) t
              module Open_on_rhs : sig  end
            end
        end
      module Syntax :
        sig
          val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
          val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
          val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
          val ( !! ) : '-> 'a t
          val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
          val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
          val ( !$$$ ) :
            ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            'a t -> 'b t -> 'c t -> 'd t -> 'e t
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
        end
      module T1 :
        functor (M : Monad->
          sig
            type 'a m = 'M.t
            type 'a t = 'Monads.Std.Monad.Lazy.T1.m Core_kernel.Std.Lazy.t
            type 'a e = 'Monads.Std.Monad.Lazy.T1.m
          end
      module Make :
        functor (M : Monad->
          sig
            val lift : 'M.t -> 'T1(M).t
            val run : 'T1(M).t -> 'Monads.Std.Monad.Lazy.T1.m
            val void : 'T1(M).t -> unit T1(M).t
            val sequence : unit T1(M).t list -> unit T1(M).t
            val forever : 'T1(M).t -> 'T1(M).t
            module Fn :
              sig
                val id : '-> 'T1(M).t
                val ignore : 'T1(M).t -> unit T1(M).t
                val nothing : unit -> unit T1(M).t
                val non : ('-> bool T1(M).t) -> '-> bool T1(M).t
                val apply_n_times :
                  n:int -> ('-> 'T1(M).t) -> '-> 'T1(M).t
                val compose :
                  ('-> 'T1(M).t) ->
                  ('-> 'T1(M).t) -> '-> 'T1(M).t
              end
            module Pair :
              sig
                val fst : ('a * 'b) T1(M).t -> 'T1(M).t
                val snd : ('a * 'b) T1(M).t -> 'T1(M).t
              end
            module Triple :
              sig
                val fst : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                val snd : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                val trd : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
              end
            module Lift :
              sig
                val nullary : '-> 'T1(M).t
                val unary : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                val binary :
                  ('-> '-> 'c) -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ternary :
                  ('-> '-> '-> 'd) ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val quaternary :
                  ('-> '-> '-> '-> 'e) ->
                  'T1(M).t ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val quinary :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'T1(M).t ->
                  'T1(M).t ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
              end
            module Exn :
              sig
                val expect :
                  ?finally:(unit -> unit T1(M).t) ->
                  f:(unit -> 'T1(M).t) ->
                  catch:(exn -> 'T1(M).t) -> 'T1(M).t
              end
            module Collection :
              sig
                module type S =
                  sig
                    type 'a t
                    val all : 'T1(M).t t -> 'a t T1(M).t
                    val all_ignore : 'T1(M).t t -> unit T1(M).t
                    val sequence : unit T1(M).t t -> unit T1(M).t
                    val map : 'a t -> f:('-> 'T1(M).t) -> 'b t T1(M).t
                    val iter : 'a t -> f:('-> unit T1(M).t) -> unit T1(M).t
                    val fold :
                      'a t ->
                      init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                    val fold_left :
                      'a t ->
                      init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                    val fold_right :
                      'a t ->
                      f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                    val reduce :
                      'a t ->
                      f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                    val exists :
                      'a t -> f:('-> bool T1(M).t) -> bool T1(M).t
                    val for_all :
                      'a t -> f:('-> bool T1(M).t) -> bool T1(M).t
                    val count : 'a t -> f:('-> bool T1(M).t) -> int T1(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b t -> f:('-> 'T1(M).t) -> 'T1(M).t
                    val find :
                      'a t -> f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                    val find_map :
                      'a t ->
                      f:('-> 'Option.t T1(M).t) -> 'Option.t T1(M).t
                    val filter :
                      'a t -> f:('-> bool T1(M).t) -> 'a t T1(M).t
                    val filter_map :
                      'a t -> f:('-> 'Option.t T1(M).t) -> 'b t T1(M).t
                  end
                module Eager :
                  functor (T : Collection.Eager->
                    sig
                      val all : 'T1(M).t T.t -> 'T.t T1(M).t
                      val all_ignore : 'T1(M).t T.t -> unit T1(M).t
                      val sequence : unit T1(M).t T.t -> unit T1(M).t
                      val map :
                        'T.t -> f:('-> 'T1(M).t) -> 'T.t T1(M).t
                      val iter :
                        'T.t -> f:('-> unit T1(M).t) -> unit T1(M).t
                      val fold :
                        'T.t ->
                        init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                      val fold_left :
                        'T.t ->
                        init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                      val reduce :
                        'T.t ->
                        f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                      val exists :
                        'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                      val for_all :
                        'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                      val count :
                        'T.t -> f:('-> bool T1(M).t) -> int T1(M).t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t -> f:('-> 'T1(M).t) -> 'T1(M).t
                      val find :
                        'T.t ->
                        f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                      val find_map :
                        'T.t ->
                        f:('-> 'Option.t T1(M).t) -> 'Option.t T1(M).t
                      val filter :
                        'T.t -> f:('-> bool T1(M).t) -> 'T.t T1(M).t
                      val filter_map :
                        'T.t ->
                        f:('-> 'Option.t T1(M).t) -> 'T.t T1(M).t
                    end
                module Delay :
                  functor (T : Collection.Delay->
                    sig
                      val all : 'T1(M).t T.t -> 'T.t T1(M).t
                      val all_ignore : 'T1(M).t T.t -> unit T1(M).t
                      val sequence : unit T1(M).t T.t -> unit T1(M).t
                      val map :
                        'T.t -> f:('-> 'T1(M).t) -> 'T.t T1(M).t
                      val iter :
                        'T.t -> f:('-> unit T1(M).t) -> unit T1(M).t
                      val fold :
                        'T.t ->
                        init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                      val fold_left :
                        'T.t ->
                        init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                      val reduce :
                        'T.t ->
                        f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                      val exists :
                        'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                      val for_all :
                        'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                      val count :
                        'T.t -> f:('-> bool T1(M).t) -> int T1(M).t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t -> f:('-> 'T1(M).t) -> 'T1(M).t
                      val find :
                        'T.t ->
                        f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                      val find_map :
                        'T.t ->
                        f:('-> 'Option.t T1(M).t) -> 'Option.t T1(M).t
                      val filter :
                        'T.t -> f:('-> bool T1(M).t) -> 'T.t T1(M).t
                      val filter_map :
                        'T.t ->
                        f:('-> 'Option.t T1(M).t) -> 'T.t T1(M).t
                    end
              end
            module List :
              sig
                val all : 'T1(M).t list -> 'a list T1(M).t
                val all_ignore : 'T1(M).t list -> unit T1(M).t
                val sequence : unit T1(M).t list -> unit T1(M).t
                val map : 'a list -> f:('-> 'T1(M).t) -> 'b list T1(M).t
                val iter : 'a list -> f:('-> unit T1(M).t) -> unit T1(M).t
                val fold :
                  'a list ->
                  init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                val fold_left :
                  'a list ->
                  init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                val fold_right :
                  'a list ->
                  f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                val reduce :
                  'a list ->
                  f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                val exists :
                  'a list -> f:('-> bool T1(M).t) -> bool T1(M).t
                val for_all :
                  'a list -> f:('-> bool T1(M).t) -> bool T1(M).t
                val count : 'a list -> f:('-> bool T1(M).t) -> int T1(M).t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'b list -> f:('-> 'T1(M).t) -> 'T1(M).t
                val find :
                  'a list -> f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                val find_map :
                  'a list ->
                  f:('-> 'Option.t T1(M).t) -> 'Option.t T1(M).t
                val filter :
                  'a list -> f:('-> bool T1(M).t) -> 'a list T1(M).t
                val filter_map :
                  'a list -> f:('-> 'Option.t T1(M).t) -> 'b list T1(M).t
              end
            module Seq :
              sig
                val all :
                  'T1(M).t Core_kernel.Std.Sequence.t ->
                  'Core_kernel.Std.Sequence.t T1(M).t
                val all_ignore :
                  'T1(M).t Core_kernel.Std.Sequence.t -> unit T1(M).t
                val sequence :
                  unit T1(M).t Core_kernel.Std.Sequence.t -> unit T1(M).t
                val map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> 'T1(M).t) ->
                  'Core_kernel.Std.Sequence.t T1(M).t
                val iter :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> unit T1(M).t) -> unit T1(M).t
                val fold :
                  'Core_kernel.Std.Sequence.t ->
                  init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                val fold_left :
                  'Core_kernel.Std.Sequence.t ->
                  init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                val fold_right :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                val reduce :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                val exists :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(M).t) -> bool T1(M).t
                val for_all :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(M).t) -> bool T1(M).t
                val count :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(M).t) -> int T1(M).t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> 'T1(M).t) -> 'T1(M).t
                val find :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                val find_map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> 'Option.t T1(M).t) -> 'Option.t T1(M).t
                val filter :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(M).t) ->
                  'Core_kernel.Std.Sequence.t T1(M).t
                val filter_map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> 'Option.t T1(M).t) ->
                  'Core_kernel.Std.Sequence.t T1(M).t
              end
            val ( >=> ) :
              ('-> 'T1(M).t) -> ('-> 'T1(M).t) -> '-> 'T1(M).t
            val ( !! ) : '-> 'T1(M).t
            val ( !$ ) : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
            val ( !$$ ) :
              ('-> '-> 'c) -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
            val ( !$$$ ) :
              ('-> '-> '-> 'd) ->
              'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
            val ( !$$$$ ) :
              ('-> '-> '-> '-> 'e) ->
              'T1(M).t ->
              'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
            val ( !$$$$$ ) :
              ('-> '-> '-> '-> '-> 'f) ->
              'T1(M).t ->
              'T1(M).t ->
              'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
            val ( >>= ) : 'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
            val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
            module Monad_infix :
              sig
                val ( >>= ) : 'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
              end
            val bind : 'T1(M).t -> f:('-> 'T1(M).t) -> 'T1(M).t
            val return : '-> 'T1(M).t
            val map : 'T1(M).t -> f:('-> 'b) -> 'T1(M).t
            val join : 'T1(M).t T1(M).t -> 'T1(M).t
            val ignore_m : 'T1(M).t -> unit T1(M).t
            val all : 'T1(M).t list -> 'a list T1(M).t
            val all_ignore : unit T1(M).t list -> unit T1(M).t
            module Let_syntax :
              sig
                val return : '-> 'T1(M).t
                val ( >>= ) : 'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                module Let_syntax :
                  sig
                    val return : '-> 'T1(M).t
                    val bind :
                      'T1(M).t -> f:('-> 'T1(M).t) -> 'T1(M).t
                    val map : 'T1(M).t -> f:('-> 'b) -> 'T1(M).t
                    val both : 'T1(M).t -> 'T1(M).t -> ('a * 'b) T1(M).t
                    module Open_on_rhs : sig  end
                  end
              end
            module Syntax :
              sig
                val ( >>= ) : 'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                val ( >=> ) :
                  ('-> 'T1(M).t) ->
                  ('-> 'T1(M).t) -> '-> 'T1(M).t
                val ( !! ) : '-> 'T1(M).t
                val ( !$ ) : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  'T1(M).t ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'T1(M).t ->
                  'T1(M).t ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
              end
          end
      module T2 :
        functor (M : Monad2->
          sig
            type ('a, 'e) m = ('a, 'e) M.t
            type ('a, 'e) t =
                ('a, 'e) Monads.Std.Monad.Lazy.T2.m Core_kernel.Std.Lazy.t
            type ('a, 'e) e = ('a, 'e) Monads.Std.Monad.Lazy.T2.m
          end
      module Make2 :
        functor (M : Monad2->
          sig
            val lift : ('a, 'e) M.t -> ('a, 'e) T2(M).t
            val run : ('a, 'e) T2(M).t -> ('a, 'e) Monads.Std.Monad.Lazy.T2.m
            val void : ('a, 'e) T2(M).t -> (unit, 'e) T2(M).t
            val sequence : (unit, 'e) T2(M).t list -> (unit, 'e) T2(M).t
            val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
            module Fn :
              sig
                val id : '-> ('a, 'e) T2(M).t
                val ignore : ('a, 'e) T2(M).t -> (unit, 'e) T2(M).t
                val nothing : unit -> (unit, 'e) T2(M).t
                val non :
                  ('-> (bool, 'e) T2(M).t) -> '-> (bool, 'e) T2(M).t
                val apply_n_times :
                  n:int -> ('-> ('a, 'e) T2(M).t) -> '-> ('a, 'e) T2(M).t
                val compose :
                  ('-> ('c, 'e) T2(M).t) ->
                  ('-> ('b, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
              end
            module Pair :
              sig
                val fst : ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
                val snd : ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
              end
            module Triple :
              sig
                val fst : ('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
                val snd : ('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
                val trd : ('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
              end
            module Lift :
              sig
                val nullary : '-> ('a, 'e) T2(M).t
                val unary :
                  ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                val binary :
                  ('-> '-> 'c) ->
                  ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                val ternary :
                  ('-> '-> '-> 'd) ->
                  ('a, 'e) T2(M).t ->
                  ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                val quaternary :
                  ('-> '-> '-> '-> 'e) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t -> ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                val quinary :
                  ('-> '-> '-> '-> '-> 'f) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t ->
                  ('d, 's) T2(M).t -> ('e, 's) T2(M).t -> ('f, 's) T2(M).t
              end
            module Exn :
              sig
                val expect :
                  ?finally:(unit -> (unit, 's) T2(M).t) ->
                  f:(unit -> ('a, 's) T2(M).t) ->
                  catch:(exn -> ('a, 's) T2(M).t) -> ('a, 's) T2(M).t
              end
            module Collection :
              sig
                module type S =
                  sig
                    type 'a t
                    val all : ('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
                    val all_ignore : ('a, 'e) T2(M).t t -> (unit, 'e) T2(M).t
                    val sequence : (unit, 'e) T2(M).t t -> (unit, 'e) T2(M).t
                    val map :
                      'a t ->
                      f:('-> ('b, 'e) T2(M).t) -> ('b t, 'e) T2(M).t
                    val iter :
                      'a t ->
                      f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                    val fold :
                      'a t ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_left :
                      'a t ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_right :
                      'a t ->
                      f:('-> '-> ('b, 'e) T2(M).t) ->
                      init:'-> ('b, 'e) T2(M).t
                    val reduce :
                      'a t ->
                      f:('-> '-> ('a, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val exists :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val for_all :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val count :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b t -> f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                    val find :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val find_map :
                      'a t ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val filter :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) -> ('a t, 'e) T2(M).t
                    val filter_map :
                      'a t ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('b t, 'e) T2(M).t
                  end
                module Eager :
                  functor (T : Collection.Eager->
                    sig
                      val all : ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                      val all_ignore :
                        ('a, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                      val sequence :
                        (unit, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                      val map :
                        'T.t ->
                        f:('-> ('b, 'e) T2(M).t) -> ('T.t, 'e) T2(M).t
                      val iter :
                        'T.t ->
                        f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                      val fold :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                      val fold_left :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> ('b, 'e) T2(M).t) ->
                        init:'-> ('b, 'e) T2(M).t
                      val reduce :
                        'T.t ->
                        f:('-> '-> ('a, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val exists :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                      val for_all :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                      val count :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t ->
                        f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                      val find :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val find_map :
                        'T.t ->
                        f:('-> ('Option.t, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val filter :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> ('T.t, 'e) T2(M).t
                      val filter_map :
                        'T.t ->
                        f:('-> ('Option.t, 'e) T2(M).t) ->
                        ('T.t, 'e) T2(M).t
                    end
                module Delay :
                  functor (T : Collection.Delay->
                    sig
                      val all : ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                      val all_ignore :
                        ('a, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                      val sequence :
                        (unit, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                      val map :
                        'T.t ->
                        f:('-> ('b, 'e) T2(M).t) -> ('T.t, 'e) T2(M).t
                      val iter :
                        'T.t ->
                        f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                      val fold :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                      val fold_left :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> ('b, 'e) T2(M).t) ->
                        init:'-> ('b, 'e) T2(M).t
                      val reduce :
                        'T.t ->
                        f:('-> '-> ('a, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val exists :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                      val for_all :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                      val count :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t ->
                        f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                      val find :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val find_map :
                        'T.t ->
                        f:('-> ('Option.t, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val filter :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> ('T.t, 'e) T2(M).t
                      val filter_map :
                        'T.t ->
                        f:('-> ('Option.t, 'e) T2(M).t) ->
                        ('T.t, 'e) T2(M).t
                    end
              end
            module List :
              sig
                val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                val all_ignore : ('a, 'e) T2(M).t list -> (unit, 'e) T2(M).t
                val sequence : (unit, 'e) T2(M).t list -> (unit, 'e) T2(M).t
                val map :
                  'a list ->
                  f:('-> ('b, 'e) T2(M).t) -> ('b list, 'e) T2(M).t
                val iter :
                  'a list ->
                  f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                val fold :
                  'a list ->
                  init:'->
                  f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val fold_left :
                  'a list ->
                  init:'->
                  f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val fold_right :
                  'a list ->
                  f:('-> '-> ('b, 'e) T2(M).t) ->
                  init:'-> ('b, 'e) T2(M).t
                val reduce :
                  'a list ->
                  f:('-> '-> ('a, 'e) T2(M).t) ->
                  ('Option.t, 'e) T2(M).t
                val exists :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                val for_all :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                val count :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'b list -> f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                val find :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> ('Option.t, 'e) T2(M).t
                val find_map :
                  'a list ->
                  f:('-> ('Option.t, 'e) T2(M).t) ->
                  ('Option.t, 'e) T2(M).t
                val filter :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> ('a list, 'e) T2(M).t
                val filter_map :
                  'a list ->
                  f:('-> ('Option.t, 'e) T2(M).t) ->
                  ('b list, 'e) T2(M).t
              end
            module Seq :
              sig
                val all :
                  ('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                  ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                val all_ignore :
                  ('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                  (unit, 'e) T2(M).t
                val sequence :
                  (unit, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                  (unit, 'e) T2(M).t
                val map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> ('b, 'e) T2(M).t) ->
                  ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                val iter :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                val fold :
                  'Core_kernel.Std.Sequence.t ->
                  init:'->
                  f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val fold_left :
                  'Core_kernel.Std.Sequence.t ->
                  init:'->
                  f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val fold_right :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> '-> ('b, 'e) T2(M).t) ->
                  init:'-> ('b, 'e) T2(M).t
                val reduce :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> '-> ('a, 'e) T2(M).t) ->
                  ('Option.t, 'e) T2(M).t
                val exists :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                val for_all :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                val count :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                val find :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) -> ('Option.t, 'e) T2(M).t
                val find_map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> ('Option.t, 'e) T2(M).t) ->
                  ('Option.t, 'e) T2(M).t
                val filter :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) ->
                  ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                val filter_map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> ('Option.t, 'e) T2(M).t) ->
                  ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
              end
            val ( >=> ) :
              ('-> ('b, 'e) T2(M).t) ->
              ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
            val ( !! ) : '-> ('a, 'e) T2(M).t
            val ( !$ ) : ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
            val ( !$$ ) :
              ('-> '-> 'c) ->
              ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
            val ( !$$$ ) :
              ('-> '-> '-> 'd) ->
              ('a, 'e) T2(M).t ->
              ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
            val ( !$$$$ ) :
              ('-> '-> '-> '-> 'e) ->
              ('a, 's) T2(M).t ->
              ('b, 's) T2(M).t ->
              ('c, 's) T2(M).t -> ('d, 's) T2(M).t -> ('e, 's) T2(M).t
            val ( !$$$$$ ) :
              ('-> '-> '-> '-> '-> 'f) ->
              ('a, 's) T2(M).t ->
              ('b, 's) T2(M).t ->
              ('c, 's) T2(M).t ->
              ('d, 's) T2(M).t -> ('e, 's) T2(M).t -> ('f, 's) T2(M).t
            val ( >>= ) :
              ('a, 'e) T2(M).t ->
              ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
            val ( >>| ) : ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
            module Let_syntax :
              sig
                val return : '-> ('a, 'b) T2(M).t
                val ( >>= ) :
                  ('a, 'e) T2(M).t ->
                  ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val ( >>| ) :
                  ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                module Let_syntax :
                  sig
                    val return : '-> ('a, 'b) T2(M).t
                    val bind :
                      ('a, 'e) T2(M).t ->
                      f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val map :
                      ('a, 'e) T2(M).t -> f:('-> 'b) -> ('b, 'e) T2(M).t
                    val both :
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
                    module Open_on_rhs : sig  end
                  end
              end
            module Monad_infix :
              sig
                val ( >>= ) :
                  ('a, 'e) T2(M).t ->
                  ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val ( >>| ) :
                  ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
              end
            val bind :
              ('a, 'e) T2(M).t ->
              f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
            val return : '-> ('a, 'b) T2(M).t
            val map : ('a, 'e) T2(M).t -> f:('-> 'b) -> ('b, 'e) T2(M).t
            val join : (('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
            val ignore_m : ('a, 'e) T2(M).t -> (unit, 'e) T2(M).t
            val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
            val all_ignore : (unit, 'e) T2(M).t list -> (unit, 'e) T2(M).t
            module Syntax :
              sig
                val ( >>= ) :
                  ('a, 'e) T2(M).t ->
                  ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val ( >>| ) :
                  ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                val ( >=> ) :
                  ('-> ('b, 'e) T2(M).t) ->
                  ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                val ( !! ) : '-> ('a, 'e) T2(M).t
                val ( !$ ) :
                  ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) ->
                  ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  ('a, 'e) T2(M).t ->
                  ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t -> ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t ->
                  ('d, 's) T2(M).t -> ('e, 's) T2(M).t -> ('f, 's) T2(M).t
              end
          end
    end
  module Cont :
    sig
      module type S =
        sig
          type 'a t
          type 'a m
          type 'a e
          val lift : 'a m -> 'a t
          val run : 'a t -> 'a e
          val void : 'a t -> unit t
          val sequence : unit t List.t -> unit t
          val forever : 'a t -> 'b t
          module Fn :
            sig
              val id : '-> 'a t
              val ignore : 'a t -> unit t
              val nothing : unit -> unit t
              val non : ('-> bool t) -> '-> bool t
              val apply_n_times : n:int -> ('-> 'a t) -> '-> 'a t
              val compose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
            end
          module Pair :
            sig
              val fst : ('a * 'b) t -> 'a t
              val snd : ('a * 'b) t -> 'b t
            end
          module Triple :
            sig
              val fst : ('a * 'b * 'c) t -> 'a t
              val snd : ('a * 'b * 'c) t -> 'b t
              val trd : ('a * 'b * 'c) t -> 'c t
            end
          module Lift :
            sig
              val nullary : '-> 'a t
              val unary : ('-> 'b) -> 'a t -> 'b t
              val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ternary :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val quaternary :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val quinary :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
            end
          module Exn :
            sig
              val expect :
                ?finally:(unit -> unit t) ->
                f:(unit -> 'a t) -> catch:(exn -> 'a t) -> 'a t
            end
          module Collection :
            sig
              module type S =
                sig
                  type 'a t
                  val all : 'a t t -> 'a t t
                  val all_ignore : 'a t t -> unit t
                  val sequence : unit t t -> unit t
                  val map : 'a t -> f:('-> 'b t) -> 'b t t
                  val iter : 'a t -> f:('-> unit t) -> unit t
                  val fold : 'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce : 'a t -> f:('-> '-> 'a t) -> 'Option.t t
                  val exists : 'a t -> f:('-> bool t) -> bool t
                  val for_all : 'a t -> f:('-> bool t) -> bool t
                  val count : 'a t -> f:('-> bool t) -> int t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b t -> f:('-> 'a t) -> 'a t
                  val find : 'a t -> f:('-> bool t) -> 'Option.t t
                  val find_map :
                    'a t -> f:('-> 'Option.t t) -> 'Option.t t
                  val filter : 'a t -> f:('-> bool t) -> 'a t t
                  val filter_map : 'a t -> f:('-> 'Option.t t) -> 'b t t
                end
              module Eager :
                functor (T : Collection.Eager->
                  sig
                    val all : 'a t T.t -> 'T.t t
                    val all_ignore : 'a t T.t -> unit t
                    val sequence : unit t T.t -> unit t
                    val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                    val iter : 'T.t -> f:('-> unit t) -> unit t
                    val fold :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_left :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_right :
                      'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                    val reduce :
                      'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                    val exists : 'T.t -> f:('-> bool t) -> bool t
                    val for_all : 'T.t -> f:('-> bool t) -> bool t
                    val count : 'T.t -> f:('-> bool t) -> int t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> 'a t) -> 'a t
                    val find : 'T.t -> f:('-> bool t) -> 'Option.t t
                    val find_map :
                      'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                    val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                    val filter_map :
                      'T.t -> f:('-> 'Option.t t) -> 'T.t t
                  end
              module Delay :
                functor (T : Collection.Delay->
                  sig
                    val all : 'a t T.t -> 'T.t t
                    val all_ignore : 'a t T.t -> unit t
                    val sequence : unit t T.t -> unit t
                    val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                    val iter : 'T.t -> f:('-> unit t) -> unit t
                    val fold :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_left :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_right :
                      'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                    val reduce :
                      'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                    val exists : 'T.t -> f:('-> bool t) -> bool t
                    val for_all : 'T.t -> f:('-> bool t) -> bool t
                    val count : 'T.t -> f:('-> bool t) -> int t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> 'a t) -> 'a t
                    val find : 'T.t -> f:('-> bool t) -> 'Option.t t
                    val find_map :
                      'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                    val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                    val filter_map :
                      'T.t -> f:('-> 'Option.t t) -> 'T.t t
                  end
            end
          module List :
            sig
              val all : 'a t List.t -> 'List.t t
              val all_ignore : 'a t List.t -> unit t
              val sequence : unit t List.t -> unit t
              val map : 'List.t -> f:('-> 'b t) -> 'List.t t
              val iter : 'List.t -> f:('-> unit t) -> unit t
              val fold : 'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_left :
                'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_right :
                'List.t -> f:('-> '-> 'b t) -> init:'-> 'b t
              val reduce : 'List.t -> f:('-> '-> 'a t) -> 'Option.t t
              val exists : 'List.t -> f:('-> bool t) -> bool t
              val for_all : 'List.t -> f:('-> bool t) -> bool t
              val count : 'List.t -> f:('-> bool t) -> int t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'List.t -> f:('-> 'a t) -> 'a t
              val find : 'List.t -> f:('-> bool t) -> 'Option.t t
              val find_map :
                'List.t -> f:('-> 'Option.t t) -> 'Option.t t
              val filter : 'List.t -> f:('-> bool t) -> 'List.t t
              val filter_map :
                'List.t -> f:('-> 'Option.t t) -> 'List.t t
            end
          module Seq :
            sig
              val all : 'a t Seq.t -> 'Seq.t t
              val all_ignore : 'a t Seq.t -> unit t
              val sequence : unit t Seq.t -> unit t
              val map : 'Seq.t -> f:('-> 'b t) -> 'Seq.t t
              val iter : 'Seq.t -> f:('-> unit t) -> unit t
              val fold : 'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_left :
                'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_right :
                'Seq.t -> f:('-> '-> 'b t) -> init:'-> 'b t
              val reduce : 'Seq.t -> f:('-> '-> 'a t) -> 'Option.t t
              val exists : 'Seq.t -> f:('-> bool t) -> bool t
              val for_all : 'Seq.t -> f:('-> bool t) -> bool t
              val count : 'Seq.t -> f:('-> bool t) -> int t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'Seq.t -> f:('-> 'a t) -> 'a t
              val find : 'Seq.t -> f:('-> bool t) -> 'Option.t t
              val find_map :
                'Seq.t -> f:('-> 'Option.t t) -> 'Option.t t
              val filter : 'Seq.t -> f:('-> bool t) -> 'Seq.t t
              val filter_map :
                'Seq.t -> f:('-> 'Option.t t) -> 'Seq.t t
            end
          val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
          val ( !! ) : '-> 'a t
          val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
          val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
          val ( !$$$ ) :
            ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            'a t -> 'b t -> 'c t -> 'd t -> 'e t
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
          val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
          val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
          module Monad_infix :
            sig
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
            end
          val bind : 'a t -> f:('-> 'b t) -> 'b t
          val return : '-> 'a t
          val map : 'a t -> f:('-> 'b) -> 'b t
          val join : 'a t t -> 'a t
          val ignore_m : 'a t -> unit t
          val all : 'a t list -> 'a list t
          val all_ignore : unit t list -> unit t
          module Let_syntax :
            sig
              val return : '-> 'a t
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              module Let_syntax :
                sig
                  val return : '-> 'a t
                  val bind : 'a t -> f:('-> 'b t) -> 'b t
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val both : 'a t -> 'b t -> ('a * 'b) t
                  module Open_on_rhs : sig  end
                end
            end
          module Syntax :
            sig
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
              val ( !! ) : '-> 'a t
              val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
              val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
            end
          type r
          val call : f:(cc:('-> 'b t) -> 'a t) -> 'a t
        end
      module type S2 =
        sig
          type ('a, 'e) t
          type 'a m
          type ('a, 'e) e
          val lift : 'a m -> ('a, 'e) t
          val run : ('a, 'e) t -> ('a, 'e) e
          val void : ('a, 'e) t -> (unit, 'e) t
          val sequence : (unit, 'e) t List.t -> (unit, 'e) t
          val forever : ('a, 'e) t -> ('b, 'e) t
          module Fn :
            sig
              val id : '-> ('a, 'e) t
              val ignore : ('a, 'e) t -> (unit, 'e) t
              val nothing : unit -> (unit, 'e) t
              val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
              val apply_n_times :
                n:int -> ('-> ('a, 'e) t) -> '-> ('a, 'e) t
              val compose :
                ('-> ('c, 'e) t) -> ('-> ('b, 'e) t) -> '-> ('c, 'e) t
            end
          module Pair :
            sig
              val fst : ('a * 'b, 'e) t -> ('a, 'e) t
              val snd : ('a * 'b, 'e) t -> ('b, 'e) t
            end
          module Triple :
            sig
              val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
              val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
              val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
            end
          module Lift :
            sig
              val nullary : '-> ('a, 'e) t
              val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val binary :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ternary :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val quaternary :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val quinary :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
            end
          module Exn :
            sig
              val expect :
                ?finally:(unit -> (unit, 's) t) ->
                f:(unit -> ('a, 's) t) ->
                catch:(exn -> ('a, 's) t) -> ('a, 's) t
            end
          module Collection :
            sig
              module type S =
                sig
                  type 'a t
                  val all : ('a, 'e) t t -> ('a t, 'e) t
                  val all_ignore : ('a, 'e) t t -> (unit, 'e) t
                  val sequence : (unit, 'e) t t -> (unit, 'e) t
                  val map : 'a t -> f:('-> ('b, 'e) t) -> ('b t, 'e) t
                  val iter : 'a t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                  val fold :
                    'a t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'a t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'a t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'a t -> f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                  val exists : 'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count : 'a t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'a t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                  val find_map :
                    'a t ->
                    f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                  val filter : 'a t -> f:('-> (bool, 'e) t) -> ('a t, 'e) t
                  val filter_map :
                    'a t -> f:('-> ('Option.t, 'e) t) -> ('b t, 'e) t
                end
              module Eager :
                functor (T : Collection.Eager->
                  sig
                    val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                    val all_ignore : ('a, 'e) t T.t -> (unit, 'e) t
                    val sequence : (unit, 'e) t T.t -> (unit, 'e) t
                    val map :
                      'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                    val iter :
                      'T.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                    val fold :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_left :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_right :
                      'T.t ->
                      f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                    val reduce :
                      'T.t ->
                      f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                    val exists :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val for_all :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val count :
                      'T.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                    val find :
                      'T.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                    val find_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                    val filter :
                      'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                    val filter_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                  end
              module Delay :
                functor (T : Collection.Delay->
                  sig
                    val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                    val all_ignore : ('a, 'e) t T.t -> (unit, 'e) t
                    val sequence : (unit, 'e) t T.t -> (unit, 'e) t
                    val map :
                      'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                    val iter :
                      'T.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                    val fold :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_left :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_right :
                      'T.t ->
                      f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                    val reduce :
                      'T.t ->
                      f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                    val exists :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val for_all :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val count :
                      'T.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                    val find :
                      'T.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                    val find_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                    val filter :
                      'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                    val filter_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                  end
            end
          module List :
            sig
              val all : ('a, 'e) t List.t -> ('List.t, 'e) t
              val all_ignore : ('a, 'e) t List.t -> (unit, 'e) t
              val sequence : (unit, 'e) t List.t -> (unit, 'e) t
              val map :
                'List.t -> f:('-> ('b, 'e) t) -> ('List.t, 'e) t
              val iter : 'List.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
              val fold :
                'List.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_left :
                'List.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_right :
                'List.t ->
                f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
              val reduce :
                'List.t ->
                f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
              val exists :
                'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val for_all :
                'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val count : 'List.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'List.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
              val find :
                'List.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
              val find_map :
                'List.t ->
                f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
              val filter :
                'List.t -> f:('-> (bool, 'e) t) -> ('List.t, 'e) t
              val filter_map :
                'List.t ->
                f:('-> ('Option.t, 'e) t) -> ('List.t, 'e) t
            end
          module Seq :
            sig
              val all : ('a, 'e) t Seq.t -> ('Seq.t, 'e) t
              val all_ignore : ('a, 'e) t Seq.t -> (unit, 'e) t
              val sequence : (unit, 'e) t Seq.t -> (unit, 'e) t
              val map : 'Seq.t -> f:('-> ('b, 'e) t) -> ('Seq.t, 'e) t
              val iter : 'Seq.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
              val fold :
                'Seq.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_left :
                'Seq.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_right :
                'Seq.t ->
                f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
              val reduce :
                'Seq.t -> f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
              val exists : 'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val for_all :
                'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val count : 'Seq.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'Seq.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
              val find :
                'Seq.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
              val find_map :
                'Seq.t ->
                f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
              val filter :
                'Seq.t -> f:('-> (bool, 'e) t) -> ('Seq.t, 'e) t
              val filter_map :
                'Seq.t -> f:('-> ('Option.t, 'e) t) -> ('Seq.t, 'e) t
            end
          val ( >=> ) :
            ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
          val ( !! ) : '-> ('a, 'e) t
          val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
          val ( !$$ ) :
            ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
          val ( !$$$ ) :
            ('-> '-> '-> 'd) ->
            ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            ('a, 's) t ->
            ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            ('a, 's) t ->
            ('b, 's) t ->
            ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
          val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
          val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
          module Let_syntax :
            sig
              val return : '-> ('a, 'b) t
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              module Let_syntax :
                sig
                  val return : '-> ('a, 'b) t
                  val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                  val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                  val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                  module Open_on_rhs : sig  end
                end
            end
          module Monad_infix :
            sig
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
            end
          val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
          val return : '-> ('a, 'b) t
          val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
          val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
          val ignore_m : ('a, 'e) t -> (unit, 'e) t
          val all : ('a, 'e) t list -> ('a list, 'e) t
          val all_ignore : (unit, 'e) t list -> (unit, 'e) t
          module Syntax :
            sig
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              val ( >=> ) :
                ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
              val ( !! ) : '-> ('a, 'e) t
              val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val ( !$$ ) :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
            end
          val call : f:(cc:('-> ('b, 'e) t) -> ('a, 'e) t) -> ('a, 'e) t
        end
      type ('a, 'r) cont
      type ('a, 'r) t = ('a, 'r) cont
      type 'a m = 'a
      type ('a, 'e) e = ('-> 'e) -> 'e
      val lift : '-> ('a, 'e) t
      val run : ('a, 'e) t -> ('a, 'e) e
      val void : ('a, 'e) t -> (unit, 'e) t
      val sequence : (unit, 'e) t List.t -> (unit, 'e) t
      val forever : ('a, 'e) t -> ('b, 'e) t
      module Fn :
        sig
          val id : '-> ('a, 'e) t
          val ignore : ('a, 'e) t -> (unit, 'e) t
          val nothing : unit -> (unit, 'e) t
          val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
          val apply_n_times : n:int -> ('-> ('a, 'e) t) -> '-> ('a, 'e) t
          val compose :
            ('-> ('c, 'e) t) -> ('-> ('b, 'e) t) -> '-> ('c, 'e) t
        end
      module Pair :
        sig
          val fst : ('a * 'b, 'e) t -> ('a, 'e) t
          val snd : ('a * 'b, 'e) t -> ('b, 'e) t
        end
      module Triple :
        sig
          val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
          val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
          val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
        end
      module Lift :
        sig
          val nullary : '-> ('a, 'e) t
          val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
          val binary :
            ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
          val ternary :
            ('-> '-> '-> 'd) ->
            ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
          val quaternary :
            ('-> '-> '-> '-> 'e) ->
            ('a, 's) t ->
            ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
          val quinary :
            ('-> '-> '-> '-> '-> 'f) ->
            ('a, 's) t ->
            ('b, 's) t ->
            ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
        end
      module Exn :
        sig
          val expect :
            ?finally:(unit -> (unit, 's) t) ->
            f:(unit -> ('a, 's) t) -> catch:(exn -> ('a, 's) t) -> ('a, 's) t
        end
      module Collection :
        sig
          module type S =
            sig
              type 'a t
              val all : ('a, 'e) cont t -> ('a t, 'e) cont
              val all_ignore : ('a, 'e) cont t -> (unit, 'e) cont
              val sequence : (unit, 'e) cont t -> (unit, 'e) cont
              val map : 'a t -> f:('-> ('b, 'e) cont) -> ('b t, 'e) cont
              val iter : 'a t -> f:('-> (unit, 'e) cont) -> (unit, 'e) cont
              val fold :
                'a t ->
                init:'-> f:('-> '-> ('b, 'e) cont) -> ('b, 'e) cont
              val fold_left :
                'a t ->
                init:'-> f:('-> '-> ('b, 'e) cont) -> ('b, 'e) cont
              val fold_right :
                'a t ->
                f:('-> '-> ('b, 'e) cont) -> init:'-> ('b, 'e) cont
              val reduce :
                'a t ->
                f:('-> '-> ('a, 'e) cont) -> ('Option.t, 'e) cont
              val exists :
                'a t -> f:('-> (bool, 'e) cont) -> (bool, 'e) cont
              val for_all :
                'a t -> f:('-> (bool, 'e) cont) -> (bool, 'e) cont
              val count : 'a t -> f:('-> (bool, 'e) cont) -> (int, 'e) cont
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'b t -> f:('-> ('a, 'e) cont) -> ('a, 'e) cont
              val find :
                'a t -> f:('-> (bool, 'e) cont) -> ('Option.t, 'e) cont
              val find_map :
                'a t ->
                f:('-> ('Option.t, 'e) cont) -> ('Option.t, 'e) cont
              val filter :
                'a t -> f:('-> (bool, 'e) cont) -> ('a t, 'e) cont
              val filter_map :
                'a t -> f:('-> ('Option.t, 'e) cont) -> ('b t, 'e) cont
            end
          module Eager :
            functor (T : Collection.Eager->
              sig
                val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                val all_ignore : ('a, 'e) t T.t -> (unit, 'e) t
                val sequence : (unit, 'e) t T.t -> (unit, 'e) t
                val map : 'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                val iter : 'T.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                val fold :
                  'T.t ->
                  init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                val fold_left :
                  'T.t ->
                  init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                val fold_right :
                  'T.t ->
                  f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                val reduce :
                  'T.t -> f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                val exists : 'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                val for_all :
                  'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                val count : 'T.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                val find :
                  'T.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                val find_map :
                  'T.t ->
                  f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                val filter :
                  'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                val filter_map :
                  'T.t -> f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
              end
          module Delay :
            functor (T : Collection.Delay->
              sig
                val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                val all_ignore : ('a, 'e) t T.t -> (unit, 'e) t
                val sequence : (unit, 'e) t T.t -> (unit, 'e) t
                val map : 'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                val iter : 'T.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
                val fold :
                  'T.t ->
                  init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                val fold_left :
                  'T.t ->
                  init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                val fold_right :
                  'T.t ->
                  f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                val reduce :
                  'T.t -> f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                val exists : 'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                val for_all :
                  'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                val count : 'T.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                val find :
                  'T.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                val find_map :
                  'T.t ->
                  f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                val filter :
                  'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                val filter_map :
                  'T.t -> f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
              end
        end
      module List :
        sig
          val all : ('a, 'e) t List.t -> ('List.t, 'e) t
          val all_ignore : ('a, 'e) t List.t -> (unit, 'e) t
          val sequence : (unit, 'e) t List.t -> (unit, 'e) t
          val map : 'List.t -> f:('-> ('b, 'e) t) -> ('List.t, 'e) t
          val iter : 'List.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
          val fold :
            'List.t -> init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
          val fold_left :
            'List.t -> init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
          val fold_right :
            'List.t -> f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
          val reduce :
            'List.t -> f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
          val exists : 'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
          val for_all : 'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
          val count : 'List.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
          val map_reduce :
            (module Monoid.S with type t = 'a) ->
            'List.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
          val find :
            'List.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
          val find_map :
            'List.t -> f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
          val filter :
            'List.t -> f:('-> (bool, 'e) t) -> ('List.t, 'e) t
          val filter_map :
            'List.t -> f:('-> ('Option.t, 'e) t) -> ('List.t, 'e) t
        end
      module Seq :
        sig
          val all : ('a, 'e) t Seq.t -> ('Seq.t, 'e) t
          val all_ignore : ('a, 'e) t Seq.t -> (unit, 'e) t
          val sequence : (unit, 'e) t Seq.t -> (unit, 'e) t
          val map : 'Seq.t -> f:('-> ('b, 'e) t) -> ('Seq.t, 'e) t
          val iter : 'Seq.t -> f:('-> (unit, 'e) t) -> (unit, 'e) t
          val fold :
            'Seq.t -> init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
          val fold_left :
            'Seq.t -> init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
          val fold_right :
            'Seq.t -> f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
          val reduce :
            'Seq.t -> f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
          val exists : 'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
          val for_all : 'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
          val count : 'Seq.t -> f:('-> (bool, 'e) t) -> (int, 'e) t
          val map_reduce :
            (module Monoid.S with type t = 'a) ->
            'Seq.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
          val find :
            'Seq.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
          val find_map :
            'Seq.t -> f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
          val filter : 'Seq.t -> f:('-> (bool, 'e) t) -> ('Seq.t, 'e) t
          val filter_map :
            'Seq.t -> f:('-> ('Option.t, 'e) t) -> ('Seq.t, 'e) t
        end
      val ( >=> ) :
        ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
      val ( !! ) : '-> ('a, 'e) t
      val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
      val ( !$$ ) :
        ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
      val ( !$$$ ) :
        ('-> '-> '-> 'd) ->
        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
      val ( !$$$$ ) :
        ('-> '-> '-> '-> 'e) ->
        ('a, 's) t -> ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
      val ( !$$$$$ ) :
        ('-> '-> '-> '-> '-> 'f) ->
        ('a, 's) t ->
        ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
      val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
      module Let_syntax :
        sig
          val return : '-> ('a, 'b) t
          val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
          val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
          module Let_syntax :
            sig
              val return : '-> ('a, 'b) t
              val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
              val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
              val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
              module Open_on_rhs : sig  end
            end
        end
      module Monad_infix :
        sig
          val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
          val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
        end
      val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
      val return : '-> ('a, 'b) t
      val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
      val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
      val ignore_m : ('a, 'e) t -> (unit, 'e) t
      val all : ('a, 'e) t list -> ('a list, 'e) t
      val all_ignore : (unit, 'e) t list -> (unit, 'e) t
      module Syntax :
        sig
          val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
          val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
          val ( >=> ) :
            ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
          val ( !! ) : '-> ('a, 'e) t
          val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
          val ( !$$ ) :
            ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
          val ( !$$$ ) :
            ('-> '-> '-> 'd) ->
            ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            ('a, 's) t ->
            ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            ('a, 's) t ->
            ('b, 's) t ->
            ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
        end
      val call : f:(cc:('-> ('b, 'e) t) -> ('a, 'e) t) -> ('a, 'e) t
      module T1 :
        functor (T : Core_kernel.Std.T) (M : Monad->
          sig
            type r = T.t
            type 'a m = 'M.t
            type 'a t =
                ('a, Monads.Std.Monad.Cont.T1.r Monads.Std.Monad.Cont.T1.m)
                Monads.Std.Monad.Cont.cont
            type 'a e =
                ('-> Monads.Std.Monad.Cont.T1.r Monads.Std.Monad.Cont.T1.m) ->
                Monads.Std.Monad.Cont.T1.r Monads.Std.Monad.Cont.T1.m
          end
      module T2 :
        functor (M : Monad->
          sig
            type 'a m = 'M.t
            type ('a, 'e) t =
                ('a, 'Monads.Std.Monad.Cont.T2.m)
                Monads.Std.Monad.Cont.cont
            type ('a, 'e) e =
                ('-> 'Monads.Std.Monad.Cont.T2.m) ->
                'Monads.Std.Monad.Cont.T2.m
          end
      module Make :
        functor (T : Core_kernel.Std.T) (M : Monad->
          sig
            val lift : 'M.t -> 'T1(T)(M).t
            val run : 'T1(T)(M).t -> 'T1(T)(M).e
            val void : 'T1(T)(M).t -> unit T1(T)(M).t
            val sequence : unit T1(T)(M).t list -> unit T1(T)(M).t
            val forever : 'T1(T)(M).t -> 'T1(T)(M).t
            module Fn :
              sig
                val id : '-> 'T1(T)(M).t
                val ignore : 'T1(T)(M).t -> unit T1(T)(M).t
                val nothing : unit -> unit T1(T)(M).t
                val non : ('-> bool T1(T)(M).t) -> '-> bool T1(T)(M).t
                val apply_n_times :
                  n:int -> ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                val compose :
                  ('-> 'T1(T)(M).t) ->
                  ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
              end
            module Pair :
              sig
                val fst : ('a * 'b) T1(T)(M).t -> 'T1(T)(M).t
                val snd : ('a * 'b) T1(T)(M).t -> 'T1(T)(M).t
              end
            module Triple :
              sig
                val fst : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                val snd : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                val trd : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
              end
            module Lift :
              sig
                val nullary : '-> 'T1(T)(M).t
                val unary : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                val binary :
                  ('-> '-> 'c) ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ternary :
                  ('-> '-> '-> 'd) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val quaternary :
                  ('-> '-> '-> '-> 'e) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val quinary :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
              end
            module Exn :
              sig
                val expect :
                  ?finally:(unit -> unit T1(T)(M).t) ->
                  f:(unit -> 'T1(T)(M).t) ->
                  catch:(exn -> 'T1(T)(M).t) -> 'T1(T)(M).t
              end
            module Collection :
              sig
                module type S =
                  sig
                    type 'a t
                    val all : 'T1(T)(M).t t -> 'a t T1(T)(M).t
                    val all_ignore : 'T1(T)(M).t t -> unit T1(T)(M).t
                    val sequence : unit T1(T)(M).t t -> unit T1(T)(M).t
                    val map :
                      'a t -> f:('-> 'T1(T)(M).t) -> 'b t T1(T)(M).t
                    val iter :
                      'a t -> f:('-> unit T1(T)(M).t) -> unit T1(T)(M).t
                    val fold :
                      'a t ->
                      init:'->
                      f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val fold_left :
                      'a t ->
                      init:'->
                      f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val fold_right :
                      'a t ->
                      f:('-> '-> 'T1(T)(M).t) ->
                      init:'-> 'T1(T)(M).t
                    val reduce :
                      'a t ->
                      f:('-> '-> 'T1(T)(M).t) -> 'Option.t T1(T)(M).t
                    val exists :
                      'a t -> f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                    val for_all :
                      'a t -> f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                    val count :
                      'a t -> f:('-> bool T1(T)(M).t) -> int T1(T)(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b t -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val find :
                      'a t ->
                      f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                    val find_map :
                      'a t ->
                      f:('-> 'Option.t T1(T)(M).t) ->
                      'Option.t T1(T)(M).t
                    val filter :
                      'a t -> f:('-> bool T1(T)(M).t) -> 'a t T1(T)(M).t
                    val filter_map :
                      'a t ->
                      f:('-> 'Option.t T1(T)(M).t) -> 'b t T1(T)(M).t
                  end
                module Eager :
                  functor (T : Collection.Eager->
                    sig
                      val all : 'T1(T)(M).t T.t -> 'T.t T1(T)(M).t
                      val all_ignore : 'T1(T)(M).t T.t -> unit T1(T)(M).t
                      val sequence : unit T1(T)(M).t T.t -> unit T1(T)(M).t
                      val map :
                        'T.t ->
                        f:('-> 'T1(T)(M).t) -> 'T.t T1(T)(M).t
                      val iter :
                        'T.t ->
                        f:('-> unit T1(T)(M).t) -> unit T1(T)(M).t
                      val fold :
                        'T.t ->
                        init:'->
                        f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                      val fold_left :
                        'T.t ->
                        init:'->
                        f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> 'T1(T)(M).t) ->
                        init:'-> 'T1(T)(M).t
                      val reduce :
                        'T.t ->
                        f:('-> '-> 'T1(T)(M).t) ->
                        'Option.t T1(T)(M).t
                      val exists :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                      val for_all :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                      val count :
                        'T.t -> f:('-> bool T1(T)(M).t) -> int T1(T)(M).t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                      val find :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                      val find_map :
                        'T.t ->
                        f:('-> 'Option.t T1(T)(M).t) ->
                        'Option.t T1(T)(M).t
                      val filter :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> 'T.t T1(T)(M).t
                      val filter_map :
                        'T.t ->
                        f:('-> 'Option.t T1(T)(M).t) -> 'T.t T1(T)(M).t
                    end
                module Delay :
                  functor (T : Collection.Delay->
                    sig
                      val all : 'T1(T)(M).t T.t -> 'T.t T1(T)(M).t
                      val all_ignore : 'T1(T)(M).t T.t -> unit T1(T)(M).t
                      val sequence : unit T1(T)(M).t T.t -> unit T1(T)(M).t
                      val map :
                        'T.t ->
                        f:('-> 'T1(T)(M).t) -> 'T.t T1(T)(M).t
                      val iter :
                        'T.t ->
                        f:('-> unit T1(T)(M).t) -> unit T1(T)(M).t
                      val fold :
                        'T.t ->
                        init:'->
                        f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                      val fold_left :
                        'T.t ->
                        init:'->
                        f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> 'T1(T)(M).t) ->
                        init:'-> 'T1(T)(M).t
                      val reduce :
                        'T.t ->
                        f:('-> '-> 'T1(T)(M).t) ->
                        'Option.t T1(T)(M).t
                      val exists :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                      val for_all :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                      val count :
                        'T.t -> f:('-> bool T1(T)(M).t) -> int T1(T)(M).t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                      val find :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                      val find_map :
                        'T.t ->
                        f:('-> 'Option.t T1(T)(M).t) ->
                        'Option.t T1(T)(M).t
                      val filter :
                        'T.t ->
                        f:('-> bool T1(T)(M).t) -> 'T.t T1(T)(M).t
                      val filter_map :
                        'T.t ->
                        f:('-> 'Option.t T1(T)(M).t) -> 'T.t T1(T)(M).t
                    end
              end
            module List :
              sig
                val all : 'T1(T)(M).t list -> 'a list T1(T)(M).t
                val all_ignore : 'T1(T)(M).t list -> unit T1(T)(M).t
                val sequence : unit T1(T)(M).t list -> unit T1(T)(M).t
                val map :
                  'a list -> f:('-> 'T1(T)(M).t) -> 'b list T1(T)(M).t
                val iter :
                  'a list -> f:('-> unit T1(T)(M).t) -> unit T1(T)(M).t
                val fold :
                  'a list ->
                  init:'-> f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val fold_left :
                  'a list ->
                  init:'-> f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val fold_right :
                  'a list ->
                  f:('-> '-> 'T1(T)(M).t) -> init:'-> 'T1(T)(M).t
                val reduce :
                  'a list ->
                  f:('-> '-> 'T1(T)(M).t) -> 'Option.t T1(T)(M).t
                val exists :
                  'a list -> f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                val for_all :
                  'a list -> f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                val count :
                  'a list -> f:('-> bool T1(T)(M).t) -> int T1(T)(M).t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'b list -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val find :
                  'a list ->
                  f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                val find_map :
                  'a list ->
                  f:('-> 'Option.t T1(T)(M).t) -> 'Option.t T1(T)(M).t
                val filter :
                  'a list -> f:('-> bool T1(T)(M).t) -> 'a list T1(T)(M).t
                val filter_map :
                  'a list ->
                  f:('-> 'Option.t T1(T)(M).t) -> 'b list T1(T)(M).t
              end
            module Seq :
              sig
                val all :
                  'T1(T)(M).t Core_kernel.Std.Sequence.t ->
                  'Core_kernel.Std.Sequence.t T1(T)(M).t
                val all_ignore :
                  'T1(T)(M).t Core_kernel.Std.Sequence.t -> unit T1(T)(M).t
                val sequence :
                  unit T1(T)(M).t Core_kernel.Std.Sequence.t ->
                  unit T1(T)(M).t
                val map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> 'T1(T)(M).t) ->
                  'Core_kernel.Std.Sequence.t T1(T)(M).t
                val iter :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> unit T1(T)(M).t) -> unit T1(T)(M).t
                val fold :
                  'Core_kernel.Std.Sequence.t ->
                  init:'-> f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val fold_left :
                  'Core_kernel.Std.Sequence.t ->
                  init:'-> f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val fold_right :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> '-> 'T1(T)(M).t) -> init:'-> 'T1(T)(M).t
                val reduce :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> '-> 'T1(T)(M).t) -> 'Option.t T1(T)(M).t
                val exists :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                val for_all :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                val count :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(T)(M).t) -> int T1(T)(M).t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val find :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                val find_map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> 'Option.t T1(T)(M).t) -> 'Option.t T1(T)(M).t
                val filter :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> bool T1(T)(M).t) ->
                  'Core_kernel.Std.Sequence.t T1(T)(M).t
                val filter_map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> 'Option.t T1(T)(M).t) ->
                  'Core_kernel.Std.Sequence.t T1(T)(M).t
              end
            val ( >=> ) :
              ('-> 'T1(T)(M).t) ->
              ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
            val ( !! ) : '-> 'T1(T)(M).t
            val ( !$ ) : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
            val ( !$$ ) :
              ('-> '-> 'c) ->
              'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
            val ( !$$$ ) :
              ('-> '-> '-> 'd) ->
              'T1(T)(M).t ->
              'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
            val ( !$$$$ ) :
              ('-> '-> '-> '-> 'e) ->
              'T1(T)(M).t ->
              'T1(T)(M).t ->
              'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
            val ( !$$$$$ ) :
              ('-> '-> '-> '-> '-> 'f) ->
              'T1(T)(M).t ->
              'T1(T)(M).t ->
              'T1(T)(M).t ->
              'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
            val ( >>= ) :
              'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
            val ( >>| ) : 'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
            module Monad_infix :
              sig
                val ( >>= ) :
                  'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val ( >>| ) : 'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
              end
            val bind :
              'T1(T)(M).t -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
            val return : '-> 'T1(T)(M).t
            val map : 'T1(T)(M).t -> f:('-> 'b) -> 'T1(T)(M).t
            val join : 'T1(T)(M).t T1(T)(M).t -> 'T1(T)(M).t
            val ignore_m : 'T1(T)(M).t -> unit T1(T)(M).t
            val all : 'T1(T)(M).t list -> 'a list T1(T)(M).t
            val all_ignore : unit T1(T)(M).t list -> unit T1(T)(M).t
            module Let_syntax :
              sig
                val return : '-> 'T1(T)(M).t
                val ( >>= ) :
                  'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val ( >>| ) : 'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                module Let_syntax :
                  sig
                    val return : '-> 'T1(T)(M).t
                    val bind :
                      'T1(T)(M).t ->
                      f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val map : 'T1(T)(M).t -> f:('-> 'b) -> 'T1(T)(M).t
                    val both :
                      'T1(T)(M).t -> 'T1(T)(M).t -> ('a * 'b) T1(T)(M).t
                    module Open_on_rhs : sig  end
                  end
              end
            module Syntax :
              sig
                val ( >>= ) :
                  'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val ( >>| ) : 'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                val ( >=> ) :
                  ('-> 'T1(T)(M).t) ->
                  ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                val ( !! ) : '-> 'T1(T)(M).t
                val ( !$ ) : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
              end
            val call :
              f:(cc:('-> 'T1(T)(M).t) -> 'T1(T)(M).t) -> 'T1(T)(M).t
          end
      module Make2 :
        functor (M : Monad->
          sig
            val lift : 'M.t -> ('a, 'e) T2(M).t
            val run : ('a, 'e) T2(M).t -> ('a, 'e) T2(M).e
            val void : ('a, 'e) T2(M).t -> (unit, 'e) T2(M).t
            val sequence : (unit, 'e) T2(M).t list -> (unit, 'e) T2(M).t
            val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
            module Fn :
              sig
                val id : '-> ('a, 'e) T2(M).t
                val ignore : ('a, 'e) T2(M).t -> (unit, 'e) T2(M).t
                val nothing : unit -> (unit, 'e) T2(M).t
                val non :
                  ('-> (bool, 'e) T2(M).t) -> '-> (bool, 'e) T2(M).t
                val apply_n_times :
                  n:int -> ('-> ('a, 'e) T2(M).t) -> '-> ('a, 'e) T2(M).t
                val compose :
                  ('-> ('c, 'e) T2(M).t) ->
                  ('-> ('b, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
              end
            module Pair :
              sig
                val fst : ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
                val snd : ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
              end
            module Triple :
              sig
                val fst : ('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
                val snd : ('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
                val trd : ('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
              end
            module Lift :
              sig
                val nullary : '-> ('a, 'e) T2(M).t
                val unary :
                  ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                val binary :
                  ('-> '-> 'c) ->
                  ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                val ternary :
                  ('-> '-> '-> 'd) ->
                  ('a, 'e) T2(M).t ->
                  ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                val quaternary :
                  ('-> '-> '-> '-> 'e) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t -> ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                val quinary :
                  ('-> '-> '-> '-> '-> 'f) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t ->
                  ('d, 's) T2(M).t -> ('e, 's) T2(M).t -> ('f, 's) T2(M).t
              end
            module Exn :
              sig
                val expect :
                  ?finally:(unit -> (unit, 's) T2(M).t) ->
                  f:(unit -> ('a, 's) T2(M).t) ->
                  catch:(exn -> ('a, 's) T2(M).t) -> ('a, 's) T2(M).t
              end
            module Collection :
              sig
                module type S =
                  sig
                    type 'a t
                    val all : ('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
                    val all_ignore : ('a, 'e) T2(M).t t -> (unit, 'e) T2(M).t
                    val sequence : (unit, 'e) T2(M).t t -> (unit, 'e) T2(M).t
                    val map :
                      'a t ->
                      f:('-> ('b, 'e) T2(M).t) -> ('b t, 'e) T2(M).t
                    val iter :
                      'a t ->
                      f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                    val fold :
                      'a t ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_left :
                      'a t ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_right :
                      'a t ->
                      f:('-> '-> ('b, 'e) T2(M).t) ->
                      init:'-> ('b, 'e) T2(M).t
                    val reduce :
                      'a t ->
                      f:('-> '-> ('a, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val exists :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val for_all :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val count :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b t -> f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                    val find :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val find_map :
                      'a t ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val filter :
                      'a t ->
                      f:('-> (bool, 'e) T2(M).t) -> ('a t, 'e) T2(M).t
                    val filter_map :
                      'a t ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('b t, 'e) T2(M).t
                  end
                module Eager :
                  functor (T : Collection.Eager->
                    sig
                      val all : ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                      val all_ignore :
                        ('a, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                      val sequence :
                        (unit, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                      val map :
                        'T.t ->
                        f:('-> ('b, 'e) T2(M).t) -> ('T.t, 'e) T2(M).t
                      val iter :
                        'T.t ->
                        f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                      val fold :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                      val fold_left :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> ('b, 'e) T2(M).t) ->
                        init:'-> ('b, 'e) T2(M).t
                      val reduce :
                        'T.t ->
                        f:('-> '-> ('a, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val exists :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                      val for_all :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                      val count :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t ->
                        f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                      val find :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val find_map :
                        'T.t ->
                        f:('-> ('Option.t, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val filter :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> ('T.t, 'e) T2(M).t
                      val filter_map :
                        'T.t ->
                        f:('-> ('Option.t, 'e) T2(M).t) ->
                        ('T.t, 'e) T2(M).t
                    end
                module Delay :
                  functor (T : Collection.Delay->
                    sig
                      val all : ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                      val all_ignore :
                        ('a, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                      val sequence :
                        (unit, 'e) T2(M).t T.t -> (unit, 'e) T2(M).t
                      val map :
                        'T.t ->
                        f:('-> ('b, 'e) T2(M).t) -> ('T.t, 'e) T2(M).t
                      val iter :
                        'T.t ->
                        f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                      val fold :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                      val fold_left :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> ('b, 'e) T2(M).t) ->
                        init:'-> ('b, 'e) T2(M).t
                      val reduce :
                        'T.t ->
                        f:('-> '-> ('a, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val exists :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                      val for_all :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                      val count :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t ->
                        f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                      val find :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val find_map :
                        'T.t ->
                        f:('-> ('Option.t, 'e) T2(M).t) ->
                        ('Option.t, 'e) T2(M).t
                      val filter :
                        'T.t ->
                        f:('-> (bool, 'e) T2(M).t) -> ('T.t, 'e) T2(M).t
                      val filter_map :
                        'T.t ->
                        f:('-> ('Option.t, 'e) T2(M).t) ->
                        ('T.t, 'e) T2(M).t
                    end
              end
            module List :
              sig
                val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                val all_ignore : ('a, 'e) T2(M).t list -> (unit, 'e) T2(M).t
                val sequence : (unit, 'e) T2(M).t list -> (unit, 'e) T2(M).t
                val map :
                  'a list ->
                  f:('-> ('b, 'e) T2(M).t) -> ('b list, 'e) T2(M).t
                val iter :
                  'a list ->
                  f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                val fold :
                  'a list ->
                  init:'->
                  f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val fold_left :
                  'a list ->
                  init:'->
                  f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val fold_right :
                  'a list ->
                  f:('-> '-> ('b, 'e) T2(M).t) ->
                  init:'-> ('b, 'e) T2(M).t
                val reduce :
                  'a list ->
                  f:('-> '-> ('a, 'e) T2(M).t) ->
                  ('Option.t, 'e) T2(M).t
                val exists :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                val for_all :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                val count :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'b list -> f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                val find :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> ('Option.t, 'e) T2(M).t
                val find_map :
                  'a list ->
                  f:('-> ('Option.t, 'e) T2(M).t) ->
                  ('Option.t, 'e) T2(M).t
                val filter :
                  'a list ->
                  f:('-> (bool, 'e) T2(M).t) -> ('a list, 'e) T2(M).t
                val filter_map :
                  'a list ->
                  f:('-> ('Option.t, 'e) T2(M).t) ->
                  ('b list, 'e) T2(M).t
              end
            module Seq :
              sig
                val all :
                  ('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                  ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                val all_ignore :
                  ('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                  (unit, 'e) T2(M).t
                val sequence :
                  (unit, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                  (unit, 'e) T2(M).t
                val map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> ('b, 'e) T2(M).t) ->
                  ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                val iter :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (unit, 'e) T2(M).t) -> (unit, 'e) T2(M).t
                val fold :
                  'Core_kernel.Std.Sequence.t ->
                  init:'->
                  f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val fold_left :
                  'Core_kernel.Std.Sequence.t ->
                  init:'->
                  f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val fold_right :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> '-> ('b, 'e) T2(M).t) ->
                  init:'-> ('b, 'e) T2(M).t
                val reduce :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> '-> ('a, 'e) T2(M).t) ->
                  ('Option.t, 'e) T2(M).t
                val exists :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                val for_all :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                val count :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) -> (int, 'e) T2(M).t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                val find :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) -> ('Option.t, 'e) T2(M).t
                val find_map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> ('Option.t, 'e) T2(M).t) ->
                  ('Option.t, 'e) T2(M).t
                val filter :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> (bool, 'e) T2(M).t) ->
                  ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                val filter_map :
                  'Core_kernel.Std.Sequence.t ->
                  f:('-> ('Option.t, 'e) T2(M).t) ->
                  ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
              end
            val ( >=> ) :
              ('-> ('b, 'e) T2(M).t) ->
              ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
            val ( !! ) : '-> ('a, 'e) T2(M).t
            val ( !$ ) : ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
            val ( !$$ ) :
              ('-> '-> 'c) ->
              ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
            val ( !$$$ ) :
              ('-> '-> '-> 'd) ->
              ('a, 'e) T2(M).t ->
              ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
            val ( !$$$$ ) :
              ('-> '-> '-> '-> 'e) ->
              ('a, 's) T2(M).t ->
              ('b, 's) T2(M).t ->
              ('c, 's) T2(M).t -> ('d, 's) T2(M).t -> ('e, 's) T2(M).t
            val ( !$$$$$ ) :
              ('-> '-> '-> '-> '-> 'f) ->
              ('a, 's) T2(M).t ->
              ('b, 's) T2(M).t ->
              ('c, 's) T2(M).t ->
              ('d, 's) T2(M).t -> ('e, 's) T2(M).t -> ('f, 's) T2(M).t
            val ( >>= ) :
              ('a, 'e) T2(M).t ->
              ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
            val ( >>| ) : ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
            module Let_syntax :
              sig
                val return : '-> ('a, 'b) T2(M).t
                val ( >>= ) :
                  ('a, 'e) T2(M).t ->
                  ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val ( >>| ) :
                  ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                module Let_syntax :
                  sig
                    val return : '-> ('a, 'b) T2(M).t
                    val bind :
                      ('a, 'e) T2(M).t ->
                      f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val map :
                      ('a, 'e) T2(M).t -> f:('-> 'b) -> ('b, 'e) T2(M).t
                    val both :
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
                    module Open_on_rhs : sig  end
                  end
              end
            module Monad_infix :
              sig
                val ( >>= ) :
                  ('a, 'e) T2(M).t ->
                  ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val ( >>| ) :
                  ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
              end
            val bind :
              ('a, 'e) T2(M).t ->
              f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
            val return : '-> ('a, 'b) T2(M).t
            val map : ('a, 'e) T2(M).t -> f:('-> 'b) -> ('b, 'e) T2(M).t
            val join : (('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
            val ignore_m : ('a, 'e) T2(M).t -> (unit, 'e) T2(M).t
            val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
            val all_ignore : (unit, 'e) T2(M).t list -> (unit, 'e) T2(M).t
            module Syntax :
              sig
                val ( >>= ) :
                  ('a, 'e) T2(M).t ->
                  ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val ( >>| ) :
                  ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                val ( >=> ) :
                  ('-> ('b, 'e) T2(M).t) ->
                  ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                val ( !! ) : '-> ('a, 'e) T2(M).t
                val ( !$ ) :
                  ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) ->
                  ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  ('a, 'e) T2(M).t ->
                  ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t -> ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t ->
                  ('d, 's) T2(M).t -> ('e, 's) T2(M).t -> ('f, 's) T2(M).t
              end
            val call :
              f:(cc:('-> ('b, 'e) T2(M).t) -> ('a, 'e) T2(M).t) ->
              ('a, 'e) T2(M).t
          end
    end
end